From fdf6485c800ec580656d7491795e10881d493afb Mon Sep 17 00:00:00 2001
From: Andy Gocke <angocke@microsoft.com>
Date: Fri, 21 Jan 2022 22:59:57 -0800
Subject: [PATCH 001/161] Add COMWrappers to crossgen (#63969)

---
 .../ILCompiler.Diagnostics.csproj             |   1 +
 .../ILCompilerComWrappers.cs                  |  32 ++++
 .../ILCompiler.Diagnostics/ISymNGenWriter.cs  |  75 ++++++++-
 .../aot/ILCompiler.Diagnostics/PdbWriter.cs   |  37 ++---
 .../SymNgenWriterWrapper.cs                   | 149 ++++++++++++++++++
 5 files changed, 268 insertions(+), 26 deletions(-)
 create mode 100644 src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompilerComWrappers.cs
 create mode 100644 src/coreclr/tools/aot/ILCompiler.Diagnostics/SymNgenWriterWrapper.cs

diff --git a/src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompiler.Diagnostics.csproj b/src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompiler.Diagnostics.csproj
index 97c97bb7de720d..0d1b23ad73b3c8 100644
--- a/src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompiler.Diagnostics.csproj
+++ b/src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompiler.Diagnostics.csproj
@@ -15,6 +15,7 @@
          binaries are up to date and which are stale. -->
     <GenerateDependencyFile>false</GenerateDependencyFile>
     <Configurations>Debug;Release;Checked</Configurations>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompilerComWrappers.cs b/src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompilerComWrappers.cs
new file mode 100644
index 00000000000000..d9972da41f76c6
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.Diagnostics/ILCompilerComWrappers.cs
@@ -0,0 +1,32 @@
+
+using System;
+using System.Collections;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.DiaSymReader
+{
+    internal unsafe sealed class ILCompilerComWrappers : ComWrappers
+    {
+        protected override unsafe ComInterfaceEntry* ComputeVtables(object obj, CreateComInterfaceFlags flags, out int count)
+        {
+            // passing the managed object to COM is not currently supported
+            throw new NotImplementedException();
+        }
+
+        protected override object CreateObject(IntPtr externalComObject, CreateObjectFlags flags)
+        {
+            // Assert use of the UniqueInstance flag since the returned Native Object Wrapper always
+            // supports IDisposable and its Dispose will always release and suppress finalization.
+            // If the wrapper doesn't always support IDisposable the assert can be relaxed.
+            Debug.Assert(flags.HasFlag(CreateObjectFlags.UniqueInstance));
+
+            // Throw an exception if the type is not supported by the implementation.
+            // Null can be returned as well, but an ArgumentNullException will be thrown for
+            // the consumer of this ComWrappers instance.
+            return SymNgenWriterWrapper.CreateIfSupported(externalComObject) ?? throw new NotSupportedException();
+        }
+
+        protected override void ReleaseObjects(IEnumerable objects) => throw new NotImplementedException();
+    }
+}
\ No newline at end of file
diff --git a/src/coreclr/tools/aot/ILCompiler.Diagnostics/ISymNGenWriter.cs b/src/coreclr/tools/aot/ILCompiler.Diagnostics/ISymNGenWriter.cs
index 4c4b6b97d60a91..40702fd187a75a 100644
--- a/src/coreclr/tools/aot/ILCompiler.Diagnostics/ISymNGenWriter.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Diagnostics/ISymNGenWriter.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#pragma warning disable 436 // SuppressUnmanagedCodeSecurityAttribute defined in source and mscorlib 
+#pragma warning disable 436 // SuppressUnmanagedCodeSecurityAttribute defined in source and mscorlib
 
 using System;
 using System.Collections.Generic;
@@ -11,9 +11,39 @@
 
 namespace Microsoft.DiaSymReader
 {
-    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("D682FD12-43dE-411C-811B-BE8404CEA126"), SuppressUnmanagedCodeSecurity]
+    /// <summary>
+    /// IUnknown COM type for writing NGen PDBs
+    /// </summary>
+    /// <remarks>
+    /// <code>
+    /// [
+    ///  object,
+    ///  uuid(d682fd12-43de-411c-811b-be8404cea126),
+    ///  pointer_default(unique)
+    /// ]
+    /// interface ISymNGenWriter : IUnknown
+    /// {
+    ///     /*
+    ///      * Add a new public symbol to the NGEN PDB.
+    ///      */
+    ///     HRESULT AddSymbol([in] BSTR pSymbol,
+    ///                       [in] USHORT iSection,
+    ///                       [in] ULONGLONG rva);
+    ///
+    ///     /*
+    ///      * Adds a new section to the NGEN PDB.
+    ///      */
+    ///     HRESULT AddSection([in] USHORT iSection,
+    ///                        [in] USHORT flags,
+    ///                        [in] long offset,
+    ///                        [in] long cb);
+    /// };
+    /// </code>
+    /// </remarks>
     internal interface ISymNGenWriter
     {
+        public static readonly Guid IID = new Guid("D682FD12-43dE-411C-811B-BE8404CEA126");
+
         // Add a new public symbol to the NGEN PDB.
         void AddSymbol([MarshalAs(UnmanagedType.BStr)] string pSymbol,
                         ushort iSection,
@@ -46,9 +76,46 @@ internal enum OMF : ushort
     }
 
 
-    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("B029E51B-4C55-4fe2-B993-9F7BC1F10DB4"), SuppressUnmanagedCodeSecurity]
+    /// <summary>
+    /// IUnknown COM type for writing NGen PDBs
+    /// </summary>
+    /// <remarks>
+    /// <code>
+    /// [
+    ///  object,
+    ///  local,
+    ///  uuid(B029E51B-4C55-4fe2-B993-9F7BC1F10DB4),
+    ///  pointer_default(unique)
+    /// ]
+    /// interface ISymNGenWriter2 : ISymNGenWriter
+    /// {
+    ///     HRESULT OpenModW([in] const wchar_t* wszModule,
+    ///                      [in] const wchar_t* wszObjFile,
+    ///                      [out] BYTE** ppmod);
+    ///
+    ///     HRESULT CloseMod([in] BYTE* pmod);
+    ///
+    ///     HRESULT ModAddSymbols([in] BYTE* pmod, [in] BYTE* pbSym, [in] long cb);
+    ///
+    ///     HRESULT ModAddSecContribEx(
+    ///         [in] BYTE* pmod,
+    ///         [in] USHORT isect,
+    ///         [in] long off,
+    ///         [in] long cb,
+    ///         [in] ULONG dwCharacteristics,
+    ///         [in] DWORD dwDataCrc,
+    ///         [in] DWORD dwRelocCrc);
+    ///
+    ///     HRESULT QueryPDBNameExW(
+    ///         [out, size_is(cchMax)] wchar_t wszPDB[],
+    ///         [in] SIZE_T cchMax);
+    /// };
+    /// </remarks>
+    /// </code>
     internal interface ISymNGenWriter2 : ISymNGenWriter
     {
+        public readonly static new Guid IID = new Guid("B029E51B-4C55-4fe2-B993-9F7BC1F10DB4");
+
         // Add a new public symbol to the NGEN PDB.
         new void AddSymbol([MarshalAs(UnmanagedType.BStr)] string pSymbol,
                         ushort iSection,
@@ -78,7 +145,7 @@ void ModAddSecContribEx(
             uint dwRelocCrc);
 
         void QueryPDBNameExW(
-            [MarshalAs(UnmanagedType.LPWStr)] StringBuilder pdb,
+            [MarshalAs(UnmanagedType.LPWStr)] char[] pdb,
             IntPtr cchMax);
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.Diagnostics/PdbWriter.cs b/src/coreclr/tools/aot/ILCompiler.Diagnostics/PdbWriter.cs
index a16d5bf19a8e67..be0d8af909f727 100644
--- a/src/coreclr/tools/aot/ILCompiler.Diagnostics/PdbWriter.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Diagnostics/PdbWriter.cs
@@ -89,7 +89,7 @@ public class PdbWriter
         Dictionary<SymDocument,int> _documentToChecksumOffsetMapping;
 
         UIntPtr _pdbMod;
-        ISymNGenWriter2 _ngenWriter;
+        SymNgenWriterWrapper _ngenWriter;
 
         static PdbWriter()
         {
@@ -116,7 +116,7 @@ private static IntPtr DllImportResolver(string libraryName, Assembly assembly, D
         private extern static void CreateNGenPdbWriter(
             [MarshalAs(UnmanagedType.LPWStr)] string ngenImagePath,
             [MarshalAs(UnmanagedType.LPWStr)] string pdbPath,
-            [MarshalAs(UnmanagedType.Interface)] out ISymNGenWriter2 ngenPdbWriter);
+            out IntPtr ngenPdbWriterPtr);
 
         public PdbWriter(string pdbPath, PDBExtraData pdbExtraData, TargetDetails target)
         {
@@ -138,23 +138,14 @@ public void WritePDBData(string dllPath, IEnumerable<MethodInfo> methods)
             {
                 try
                 {
-                    try
-                    {
-                        WritePDBDataHelper(dllPath, methods);
-                    }
-                    finally
-                    {
-                        if ((_ngenWriter != null) && (_pdbMod != UIntPtr.Zero))
-                        {
-                            _ngenWriter.CloseMod(_pdbMod);
-                        }
-                    }
+                    WritePDBDataHelper(dllPath, methods);
                 }
                 finally
                 {
-                    if (_ngenWriter != null)
+                    if ((_ngenWriter != null) && (_pdbMod != UIntPtr.Zero))
                     {
-                        Marshal.FinalReleaseComObject(_ngenWriter);
+                        _ngenWriter.CloseMod(_pdbMod);
+                        _ngenWriter?.Dispose();
                     }
                 }
 
@@ -217,14 +208,16 @@ private void WritePDBDataHelper(string dllPath, IEnumerable<MethodInfo> methods)
             // Delete any preexisting PDB file upfront, otherwise CreateNGenPdbWriter silently opens it
             File.Delete(_pdbFilePath);
 
-            CreateNGenPdbWriter(dllPath, _pdbFilePath, out _ngenWriter);
+            var comWrapper = new ILCompilerComWrappers();
+            CreateNGenPdbWriter(dllPath, _pdbFilePath, out var pdbWriterInst);
+            _ngenWriter = (SymNgenWriterWrapper)comWrapper.GetOrCreateObjectForComInstance(pdbWriterInst, CreateObjectFlags.UniqueInstance);
 
             {
                 // PDB file is now created. Get its path and update _pdbFilePath so the PDB file
                 // can be deleted if we don't make it successfully to the end.
-                StringBuilder pdbFilePathBuilder = new StringBuilder();
-                pdbFilePathBuilder.Capacity = 1024;
-                _ngenWriter.QueryPDBNameExW(pdbFilePathBuilder, new IntPtr(pdbFilePathBuilder.Capacity));
+                const int capacity = 1024;
+                var pdbFilePathBuilder = new char[capacity];
+                _ngenWriter.QueryPDBNameExW(pdbFilePathBuilder, new IntPtr(capacity - 1) /* remove 1 byte for null */);
                 _pdbFilePath = pdbFilePathBuilder.ToString();
             }
 
@@ -428,9 +421,9 @@ private void WriteCompilerVersion()
                 byte iLanguage = (byte)CV_CFL_LANG.CV_CFL_MSIL;
                 writer.Write(iLanguage);
                 // Write rest of flags
-                writer.Write((byte)0); 
-                writer.Write((byte)0); 
-                writer.Write((byte)0); 
+                writer.Write((byte)0);
+                writer.Write((byte)0);
+                writer.Write((byte)0);
 
                 switch (_target.Architecture)
                 {
diff --git a/src/coreclr/tools/aot/ILCompiler.Diagnostics/SymNgenWriterWrapper.cs b/src/coreclr/tools/aot/ILCompiler.Diagnostics/SymNgenWriterWrapper.cs
new file mode 100644
index 00000000000000..8a1166f43a39bf
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.Diagnostics/SymNgenWriterWrapper.cs
@@ -0,0 +1,149 @@
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+#nullable enable
+
+namespace Microsoft.DiaSymReader
+{
+    internal class SymNgenWriterWrapper : ISymNGenWriter2, IDisposable
+    {
+        private bool _isDisposed = false;
+        public IntPtr ISymNGenWriter2Inst { get; }
+
+        private SymNgenWriterWrapper(IntPtr writer2Inst)
+        {
+            ISymNGenWriter2Inst = writer2Inst;
+        }
+
+        public static SymNgenWriterWrapper? CreateIfSupported(IntPtr ptr)
+        {
+            var iid = ISymNGenWriter2.IID;
+            int hr = Marshal.QueryInterface(ptr, ref iid, out IntPtr ngenWriterInst);
+            if (hr != 0)
+            {
+                return null;
+            }
+
+            return new SymNgenWriterWrapper(ngenWriterInst);
+        }
+
+        ~SymNgenWriterWrapper()
+        {
+            DisposeInternal();
+        }
+
+        public void Dispose()
+        {
+            DisposeInternal();
+            GC.SuppressFinalize(this);
+        }
+
+        private void DisposeInternal()
+        {
+            if (_isDisposed)
+            {
+                return;
+            }
+            Marshal.Release(ISymNGenWriter2Inst);
+            _isDisposed = true;
+        }
+
+        public unsafe void AddSymbol(string pSymbol, ushort iSection, ulong rva)
+        {
+            IntPtr strLocal = Marshal.StringToBSTR(pSymbol);
+            var inst = ISymNGenWriter2Inst;
+            var func = (delegate* unmanaged<IntPtr, IntPtr, ushort, ulong, int>)(*(*(void***)inst + 3 /* ISymNGenWriter2.AddSymbol slot */));
+            int hr = func(inst, strLocal, iSection, rva);
+            Marshal.FreeBSTR(strLocal);
+            if (hr != 0)
+            {
+                Marshal.ThrowExceptionForHR(hr);
+            }
+        }
+
+        public unsafe void AddSection(ushort iSection, OMF flags, int offset, int cb)
+        {
+            var inst = ISymNGenWriter2Inst;
+            var func = (delegate* unmanaged<IntPtr, ushort, OMF, int, int, int>)(*(*(void***)inst + 4));
+            int hr = func(inst, iSection, flags, offset, cb);
+            if (hr != 0)
+            {
+                Marshal.ThrowExceptionForHR(hr);
+            }
+        }
+
+        public unsafe void OpenModW(string wszModule, string wszObjFile, out UIntPtr ppmod)
+        {
+            var inst = ISymNGenWriter2Inst;
+            fixed (char* wszModulePtr = wszModule)
+            fixed (char* wszObjFilePtr = wszObjFile)
+            {
+                UIntPtr ppmodPtr;
+                var func = (delegate* unmanaged<IntPtr, char*, char*, UIntPtr*, int>)(*(*(void***)inst + 5));
+                int hr = func(inst, wszModulePtr, wszObjFilePtr, &ppmodPtr);
+                ppmod = ppmodPtr;
+                if (hr != 0)
+                {
+                    Marshal.ThrowExceptionForHR(hr);
+                }
+            }
+        }
+
+        public unsafe void CloseMod(UIntPtr pmod)
+        {
+            var inst = ISymNGenWriter2Inst;
+            var func = (delegate* unmanaged<IntPtr, UIntPtr, int>)(*(*(void***)inst + 6));
+            int hr = func(inst, pmod);
+            if (hr != 0)
+            {
+                Marshal.ThrowExceptionForHR(hr);
+            }
+        }
+
+        public unsafe void ModAddSymbols(UIntPtr pmod, byte[] pbSym, int cb)
+        {
+            fixed (byte* pbSymPtr = pbSym)
+            {
+                var pbSymLocal = (IntPtr)pbSymPtr;
+                var inst = ISymNGenWriter2Inst;
+                var func = (delegate* unmanaged<IntPtr, UIntPtr, IntPtr, int, int>)(*(*(void***)inst + 7));
+                int hr = func(inst, pmod, pbSymLocal, cb);
+                if (hr != 0)
+                {
+                    Marshal.ThrowExceptionForHR(hr);
+                }
+            }
+        }
+
+        public unsafe void ModAddSecContribEx(UIntPtr pmod, ushort isect, int off, int cb, uint dwCharacteristics, uint dwDataCrc, uint dwRelocCrc)
+        {
+            var inst = ISymNGenWriter2Inst;
+            var func = (delegate* unmanaged<IntPtr, UIntPtr, ushort, int, int, uint, uint, uint, int>)(*(*(void***)inst + 8));
+            int hr = func(inst, pmod, isect, off, cb, dwCharacteristics, dwDataCrc, dwRelocCrc);
+            if (hr != 0)
+            {
+                Marshal.ThrowExceptionForHR(hr);
+            }
+        }
+
+        public unsafe void QueryPDBNameExW(char[] pdb, IntPtr cchMax)
+        {
+            fixed (char* pdbPtr = pdb)
+            {
+                var pdbLocal = (IntPtr)pdbPtr;
+                var inst = ISymNGenWriter2Inst;
+                var func = (delegate* unmanaged<IntPtr, char*, IntPtr, int>)(*(*(void***)inst + 9));
+                int hr = func(inst, pdbPtr, cchMax);
+                if (hr != 0)
+                {
+                    Marshal.ThrowExceptionForHR(hr);
+                }
+            }
+        }
+
+        void ISymNGenWriter.AddSymbol(string pSymbol, ushort iSection, ulong rva) => AddSymbol(pSymbol, iSection, rva);
+        void ISymNGenWriter.AddSection(ushort iSection, OMF flags, int offset, int cb) => AddSection(iSection, flags, offset, cb);
+    }
+}

From 068295b281070c1efaa4b11522d7d8ce96244b42 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Sat, 22 Jan 2022 02:10:06 -0500
Subject: [PATCH 002/161] pipelines: Add wasm jobs (#64109)

---
 eng/pipelines/runtime-extra-platforms.yml |  45 +-----
 eng/pipelines/runtime-staging.yml         | 174 ++++++++++++++++++++++
 eng/pipelines/runtime.yml                 |  45 +++++-
 src/tests/issues.targets                  |   3 +
 4 files changed, 222 insertions(+), 45 deletions(-)

diff --git a/eng/pipelines/runtime-extra-platforms.yml b/eng/pipelines/runtime-extra-platforms.yml
index d9121f4b8027a0..a0642f4ab521c7 100644
--- a/eng/pipelines/runtime-extra-platforms.yml
+++ b/eng/pipelines/runtime-extra-platforms.yml
@@ -177,7 +177,7 @@ jobs:
         value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
     jobParameters:
       testGroup: innerloop
-      nameSuffix: ConsoleBrowserTests
+      nameSuffix: LibraryTests
       buildArgs: -subset mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:BrowserHost=windows
       timeoutInMinutes: 180
       condition: >-
@@ -221,7 +221,7 @@ jobs:
     jobParameters:
       isExtraPlatforms: ${{ variables.isExtraPlatformsBuild }}
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_EAT
+      nameSuffix: LibraryTests_EAT
       buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=false
       timeoutInMinutes: 180
       condition: >-
@@ -265,7 +265,7 @@ jobs:
     jobParameters:
       isExtraPlatforms: ${{ variables.isExtraPlatformsBuild }}
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_AOT
+      nameSuffix: LibraryTests_AOT
       buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=true /p:BrowserHost=$(_hostedOs)
       timeoutInMinutes: 180
       condition: >-
@@ -288,43 +288,6 @@ jobs:
           eq(variables['monoContainsChange'], true),
           eq(variables['isRollingBuild'], true))
 
-#
-# Build the whole product using Mono and run runtime tests
-#
-- template: /eng/pipelines/common/platform-matrix.yml
-  parameters:
-    jobTemplate: /eng/pipelines/common/global-build-job.yml
-    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
-    buildConfig: Release
-    runtimeFlavor: mono
-    platforms:
-    - Browser_wasm
-    variables:
-      - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
-        - name: _HelixSource
-          value: pr/dotnet/runtime/$(Build.SourceBranch)
-      - ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
-        - name: _HelixSource
-          value: ci/dotnet/runtime/$(Build.SourceBranch)
-      - name: timeoutPerTestInMinutes
-        value: 10
-      - name: timeoutPerTestCollectionInMinutes
-        value: 200
-    jobParameters:
-      testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_RuntimeTests
-      buildArgs: -s mono+libs -c $(_BuildConfig)
-      timeoutInMinutes: 180
-      condition: >-
-        or(
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
-          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
-          eq(variables['isRollingBuild'], true))
-      extraStepsTemplate: /eng/pipelines/common/templates/runtimes/wasm-runtime-and-send-to-helix.yml
-      extraStepsParameters:
-        creator: dotnet-bot
-        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
-
 #
 # Build the whole product using Mono and run libraries tests
 #
@@ -562,7 +525,7 @@ jobs:
         value: $[ dependencies.evaluate_paths.outputs['SetPathVars_wasmdebuggertests.containsChange'] ]
     jobParameters:
       testGroup: innerloop
-      nameSuffix: Windows_wasm_DebuggerTests
+      nameSuffix: Mono_DebuggerTests
       buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:TestWasmDebuggerTests=true /p:TestAssemblies=false /p:BrowserHost=windows
       timeoutInMinutes: 180
       condition: >-
diff --git a/eng/pipelines/runtime-staging.yml b/eng/pipelines/runtime-staging.yml
index 42803677d00371..d49ceeed3ef533 100644
--- a/eng/pipelines/runtime-staging.yml
+++ b/eng/pipelines/runtime-staging.yml
@@ -273,6 +273,180 @@ jobs:
           creator: dotnet-bot
           testRunNamePrefixSuffix: Mono_$(_BuildConfig)
 
+#
+# Build the whole product using Mono and run libraries tests, for Wasm.Build.Tests
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    buildConfig: Release
+    runtimeFlavor: mono
+    platforms:
+    - Browser_wasm_win
+    variables:
+      # map dependencies variables to local variables
+      - name: wasmbuildtestsContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'] ]
+    jobParameters:
+      isExtraPlatforms: ${{ variables.isExtraPlatformsBuild }}
+      testGroup: innerloop
+      nameSuffix: WasmBuildTests
+      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:TestWasmBuildTests=true /p:TestAssemblies=false /p:BrowserHost=$(_hostedOs)
+      timeoutInMinutes: 180
+      condition: >-
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'], true)
+      # extra steps, run tests
+      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Mono_$(_BuildConfig)_$(_hostedOs)
+        extraHelixArguments: /p:BrowserHost=$(_hostedOs)
+        scenarios:
+        - buildwasmapps
+        condition: >-
+            eq(variables['wasmbuildtestsContainsChange'], true)
+
+#
+# Build Browser_wasm, on windows, run console and browser tests
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    buildConfig: release
+    runtimeFlavor: mono
+    platforms:
+    - Browser_wasm_win
+    variables:
+      # map dependencies variables to local variables
+      - name: librariesContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+      - name: monoContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
+    jobParameters:
+      testGroup: innerloop
+      nameSuffix: LibraryTests
+      buildArgs: -subset mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:BrowserHost=windows
+      timeoutInMinutes: 180
+      condition: >-
+        or(
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true))
+      # extra steps, run tests
+      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Windows_wasm_$(_BuildConfig)
+        extraHelixArguments: /p:BrowserHost=windows
+        scenarios:
+        - normal
+        - wasmtestonbrowser
+        condition: >-
+          or(
+            eq(variables['librariesContainsChange'], true),
+            eq(variables['monoContainsChange'], true),
+            eq(variables['isRollingBuild'], true))
+
+#
+# Build for Browser/wasm with RunAOTCompilation=true
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    buildConfig: Release
+    runtimeFlavor: mono
+    platforms:
+    - Browser_wasm_win
+    variables:
+      # map dependencies variables to local variables
+      - name: librariesContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+      - name: monoContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
+    jobParameters:
+      isExtraPlatforms: ${{ variables.isExtraPlatformsBuild }}
+      testGroup: innerloop
+      nameSuffix: LibraryTests_AOT
+      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=true /p:BrowserHost=$(_hostedOs)
+      timeoutInMinutes: 180
+      condition: >-
+        or(
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true))
+      # extra steps, run tests
+      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Mono_AOT_$(_BuildConfig)_$(_hostedOs)
+        extraHelixArguments: /p:NeedsToBuildWasmAppsOnHelix=true $(_runSmokeTestsOnlyArg) /p:BrowserHost=$(_hostedOs)
+        scenarios:
+        - normal
+        condition: >-
+          or(
+          eq(variables['librariesContainsChange'], true),
+          eq(variables['monoContainsChange'], true))
+
+# Wasm debugger tests - windows
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    buildConfig: Release
+    runtimeFlavor: mono
+    platforms:
+    - Browser_wasm_win
+    variables:
+      # map dependencies variables to local variables
+      - name: wasmdebuggertestsContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_wasmdebuggertests.containsChange'] ]
+    jobParameters:
+      testGroup: innerloop
+      nameSuffix: Mono_DebuggerTests
+      buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:TestWasmDebuggerTests=true /p:TestAssemblies=false /p:BrowserHost=windows
+      timeoutInMinutes: 180
+      condition: >-
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_wasmdebuggertests.containsChange'], true)
+      # extra steps, run tests
+      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        extraHelixArguments: /p:BrowserHost=windows
+        scenarios:
+        - wasmdebuggertests
+
+# Wasm debugger tests
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    buildConfig: Release
+    runtimeFlavor: mono
+    platforms:
+    - Browser_wasm
+    variables:
+      # map dependencies variables to local variables
+      - name: wasmdebuggertestsContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_wasmdebuggertests.containsChange'] ]
+    jobParameters:
+      testGroup: innerloop
+      nameSuffix: Mono_DebuggerTests
+      buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:TestWasmDebuggerTests=true /p:TestAssemblies=false
+      timeoutInMinutes: 180
+      condition: >-
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_wasmdebuggertests.containsChange'], true)
+      # extra steps, run tests
+      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        scenarios:
+        - wasmdebuggertests
+
 #
 # Build the whole product using Mono for Android and run runtime tests with Android devices
 #
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index cfc899e8d808de..7fb2493bac4790 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -364,7 +364,7 @@ jobs:
         value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
     jobParameters:
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono
+      nameSuffix: LibraryTests
       buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
       timeoutInMinutes: 180
       condition: >-
@@ -404,7 +404,7 @@ jobs:
         value: $[ dependencies.evaluate_paths.outputs['SetPathVars_wasmbuildtests.containsChange'] ]
     jobParameters:
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_WasmBuildTests
+      nameSuffix: WasmBuildTests
       buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:TestWasmBuildTests=true /p:TestAssemblies=false
       timeoutInMinutes: 180
       condition: >-
@@ -442,7 +442,7 @@ jobs:
         value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
     jobParameters:
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_EAT
+      nameSuffix: LibraryTests_EAT
       buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=false
       timeoutInMinutes: 180
       condition: >-
@@ -484,7 +484,7 @@ jobs:
         value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
     jobParameters:
       testGroup: innerloop
-      nameSuffix: AllSubsets_Mono_AOT
+      nameSuffix: LibraryTests_AOT
       buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:EnableAggressiveTrimming=true /p:BuildAOTTestsOnHelix=true /p:RunAOTCompilation=true
       timeoutInMinutes: 180
       condition: >-
@@ -507,6 +507,43 @@ jobs:
           eq(variables['monoContainsChange'], true),
           eq(variables['isRollingBuild'], true))
 
+#
+# Build the whole product using Mono and run runtime tests
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
+    buildConfig: Release
+    runtimeFlavor: mono
+    platforms:
+    - Browser_wasm
+    variables:
+      - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
+        - name: _HelixSource
+          value: pr/dotnet/runtime/$(Build.SourceBranch)
+      - ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
+        - name: _HelixSource
+          value: ci/dotnet/runtime/$(Build.SourceBranch)
+      - name: timeoutPerTestInMinutes
+        value: 10
+      - name: timeoutPerTestCollectionInMinutes
+        value: 200
+    jobParameters:
+      testGroup: innerloop
+      nameSuffix: AllSubsets_Mono_RuntimeTests
+      buildArgs: -s mono+libs -c $(_BuildConfig)
+      timeoutInMinutes: 180
+      condition: >-
+        or(
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
+          eq(variables['isRollingBuild'], true))
+      extraStepsTemplate: /eng/pipelines/common/templates/runtimes/wasm-runtime-and-send-to-helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+
 # Build and test libraries under single-file publishing
 - template: /eng/pipelines/common/platform-matrix.yml
   parameters:
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index 3269c33f9bd462..7b718aa15617d3 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -1985,6 +1985,9 @@
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Directed/debugging/debuginfo/**">
             <Issue>Tests coreclr JIT's debug info generation</Issue>
         </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/Interop/DisabledRuntimeMarshalling/**">
+            <Issue>https://github.com/dotnet/runtime/issues/64127</Issue>
+        </ExcludeList>
     </ItemGroup>
 
     <!-- Known failures for mono runtime on *all* architectures/operating systems in interpreter runtime mode -->

From 71a6433a44f55d140115cd8da678e2cbb18c55aa Mon Sep 17 00:00:00 2001
From: Floris Westerman <me@floriswesterman.nl>
Date: Sat, 22 Jan 2022 08:31:21 +0100
Subject: [PATCH 003/161] Fixing update issue with multivalued properties
 #34267 (#56696)

* Add custom attribute test

* Adding test demonstrating issue #34267

* Solution for issue #34267

Replacing all values in property with the new collection, instead of just
appending new values, leaving old values in place.

* Incorporate review feedback

Changing the variable name
---
 .../AD/ADStoreCtx_LoadStore.cs                |  11 +-
 .../tests/AccountManagementTests.cs           | 147 ++++++++++++++++++
 2 files changed, 157 insertions(+), 1 deletion(-)

diff --git a/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/AD/ADStoreCtx_LoadStore.cs b/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/AD/ADStoreCtx_LoadStore.cs
index 709ccb1601f734..2d8eebfc84ee79 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/AD/ADStoreCtx_LoadStore.cs
+++ b/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/AD/ADStoreCtx_LoadStore.cs
@@ -1357,6 +1357,12 @@ protected static void ExtensionCacheToLdapConverter(Principal p, string property
                             valueCollection = (ICollection)kvp.Value.Value;
                         }
 
+                        // We make a local copy of all elements to set, instead of adding them to the real property
+                        // directly. This allows us to override all existing elements without using Clear() and then Add(),
+                        // as that order sends a Clear operation and then a number of Append operations, which will fail.
+                        // Instead, setting the new list all at once will send a Clear operation and then an Update operation.
+                        var propertyValueList = new List<object>();
+
                         foreach (object oVal in valueCollection)
                         {
                             if (null != oVal)
@@ -1373,8 +1379,11 @@ protected static void ExtensionCacheToLdapConverter(Principal p, string property
                             if (p.unpersisted && null == oVal)
                                 continue;
 
-                            de.Properties[kvp.Key].Add(oVal);
+                            propertyValueList.Add(oVal);
                         }
+
+                        de.Properties[kvp.Key].Value = propertyValueList.ToArray();
+
                         GlobalDebug.WriteLineIf(GlobalDebug.Info, "ADStoreCtx", "ExtensionCacheToLdapConverter - Collection complete");
                     }
                     else
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs b/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs
index 4796aa44515585..10dde4837cc6d3 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs
+++ b/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs
@@ -7,6 +7,7 @@
 using System.DirectoryServices.Tests;
 using System.Linq;
 using Xunit;
+using System.Collections.Generic;
 
 namespace System.DirectoryServices.AccountManagement.Tests
 {
@@ -325,6 +326,7 @@ public void TestUpdateUserAndGroupData()
                     using (GroupPrincipal gp = FindGroup(g1.Name, context)) { Assert.Equal(group.DisplayName, gp.DisplayName); }
 
                     user.DisplayName = "Updated CoreFx Test Child User 4";
+                    
                     user.Save();
                     group.DisplayName = "Updated CoreFX Test Group Container 4";
                     group.Save();
@@ -365,6 +367,91 @@ public void TestCredentials()
             }
         }
 
+        [ConditionalFact(nameof(IsActiveDirectoryServer))]
+        public void TestCustomUserAttributes()
+        {
+            var userData = CustomUserData.GenerateUserData("CustomCoreFxUser1");
+
+            DeleteUser(userData.Name);
+
+            try
+            {
+                using var context = DomainContext;
+                using (var principal = CreateCustomUser(context, userData))
+                {
+                    Assert.NotNull(principal);
+                    ValidateRecentAddedUser(context, userData);
+                    ValidateUserUsingPrincipal(context, principal);
+
+                    using var foundPrincipal = FindCustomUser(userData.Name, context);
+                    Assert.NotNull(foundPrincipal);
+
+                    Assert.Equal(userData.PostalCode, foundPrincipal.PostalCode);
+                    Assert.Equal(principal.PostalCode, foundPrincipal.PostalCode);
+
+                    Assert.Equal(userData.PostalAddress, foundPrincipal.PostalAddress);
+                    Assert.Equal(principal.PostalAddress, foundPrincipal.PostalAddress);
+                }
+            }
+            finally
+            {
+                DeleteUser(userData.Name);
+            }
+        }
+
+        [ConditionalFact(nameof(IsActiveDirectoryServer))]
+        public void TestMultiValueCustomAttributes()
+        {
+            var userData = CustomUserData.GenerateUserData("CustomCoreFxUser2");
+            userData.PostalAddress.Add("Second address");
+
+            DeleteUser(userData.Name);
+
+            // Check whether directory-data is equivalent to expected data
+            void CheckAddressWithDirectory(PrincipalContext context, List<string> address)
+            {
+                using var foundPrincipal = FindCustomUser(userData.Name, context);
+                Assert.NotNull(foundPrincipal);
+                Assert.Equal(address.ToHashSet(), foundPrincipal.PostalAddress.ToHashSet());
+            };
+
+            // Helper to update list
+            void UpdateAddressList(CustomUserPrincipal principal, Action<List<string>> update)
+            {
+                var localCopy = principal.PostalAddress;
+                update(localCopy);
+                principal.PostalAddress = localCopy;
+                principal.Save();
+            }
+
+            try
+            {
+                // Initial setup
+                using var context = DomainContext;
+                using var principal = CreateCustomUser(context, userData);
+                Assert.NotNull(principal);
+                Assert.Equal(userData.PostalAddress, principal.PostalAddress);
+
+                CheckAddressWithDirectory(context, principal.PostalAddress);
+
+                // Add address
+                UpdateAddressList(principal, addresses => addresses.Add("Third address"));
+                CheckAddressWithDirectory(context, principal.PostalAddress);
+
+                // Remove address
+                UpdateAddressList(principal, addresses => addresses.Remove("Second address"));
+                CheckAddressWithDirectory(context, principal.PostalAddress);
+
+                // Remove address so we have one remaining
+                UpdateAddressList(principal, addresses => addresses.Remove("Third address"));
+                CheckAddressWithDirectory(context, principal.PostalAddress);
+            }
+            finally
+            {
+                DeleteUser(userData.Name);
+            }
+        }
+
         private void ValidateRecentAddedUser(PrincipalContext context, UserData userData)
         {
             using (UserPrincipal p = FindUser(userData.Name, context))
@@ -440,6 +527,20 @@ private UserPrincipal CreateUser(PrincipalContext context, UserData userData)
             return user;
         }
 
+        private CustomUserPrincipal CreateCustomUser(PrincipalContext context, CustomUserData userData)
+        {
+            CustomUserPrincipal user = new CustomUserPrincipal(context, userData.Name, userData.Password, true);
+
+            // assign some properties to the custom user principal
+            user.GivenName = userData.FirstName;
+            user.Surname = userData.LastName;
+            user.DisplayName = userData.DisplayName;
+            user.PostalCode = userData.PostalCode;
+            user.PostalAddress = userData.PostalAddress;
+            user.Save();
+            return user;
+        }
+
         private GroupPrincipal CreateGroup(PrincipalContext context, GroupData groupData)
         {
             GroupPrincipal group = new GroupPrincipal(context, groupData.Name);
@@ -493,6 +594,11 @@ private UserPrincipal FindUser(string userName, PrincipalContext context)
             return UserPrincipal.FindByIdentity(context, IdentityType.Name, userName);
         }
 
+        private CustomUserPrincipal FindCustomUser(string userName, PrincipalContext context)
+        {
+            return CustomUserPrincipal.FindByIdentity(context, IdentityType.SamAccountName, userName);
+        }
+
         private UserPrincipal FindUserUsingFilter(string userName, PrincipalContext context)
         {
             CustomUserPrincipal userPrincipal = new CustomUserPrincipal(context);
@@ -528,6 +634,23 @@ internal static UserData GenerateUserData(string name)
         internal string DisplayName { get; set; }
     }
 
+    internal class CustomUserData : UserData
+    {
+        internal static new CustomUserData GenerateUserData(string name) => new CustomUserData
+        {
+            Name = name,
+            Password = Guid.NewGuid().ToString() + "#1aZ",
+            FirstName = "First " + name,
+            LastName = "Last " + name,
+            DisplayName = "Display " + name,
+            PostalAddress = new List<string> { "Postal Address " + name },
+            PostalCode = "Code " + name
+        };
+
+        internal string PostalCode { get; set; }
+        internal List<string> PostalAddress { get; set; }
+    }
+
     internal class GroupData
     {
         internal static GroupData GenerateGroupData(string name)
@@ -545,11 +668,14 @@ internal static GroupData GenerateGroupData(string name)
     }
 
     [DirectoryObjectClass("user")]
+    [DirectoryRdnPrefix("CN")]
     public class CustomUserPrincipal : UserPrincipal
     {
         private CustomFilter _customFilter;
 
         public CustomUserPrincipal(PrincipalContext context) : base(context) { }
+        public CustomUserPrincipal(PrincipalContext context, string samAccountName, string password, bool enabled)
+            : base(context, samAccountName, password, enabled) { }
 
         public void SetUserNameFilter(string name)
         {
@@ -568,6 +694,27 @@ public override AdvancedFilters AdvancedSearchFilter
                 return _customFilter;
             }
         }
+
+        // Custom properties
+        [DirectoryProperty("postalCode")]
+        public string PostalCode
+        {
+            get => ExtensionGet("postalCode").FirstOrDefault() as string;
+            set => ExtensionSet("postalCode", value);
+        }
+
+        [DirectoryProperty("postalAddress")]
+        public List<string> PostalAddress
+        {
+            get => ExtensionGet("postalAddress").OfType<string>().ToList();
+            set => ExtensionSet("postalAddress", value == null || value?.Count == 0 ? null : value.ToArray());
+        }
+
+        // Method overrides
+        public new static CustomUserPrincipal FindByIdentity(PrincipalContext context, IdentityType identityType, string identityValue)
+        {
+            return FindByIdentityWithType(context, typeof(CustomUserPrincipal), identityType, identityValue) as CustomUserPrincipal;
+        }
     }
 
     public class CustomFilter : AdvancedFilters

From 64245ab3966abde394767fbd6531e7edbea2802e Mon Sep 17 00:00:00 2001
From: Jan Kotas <jkotas@microsoft.com>
Date: Fri, 21 Jan 2022 23:56:14 -0800
Subject: [PATCH 004/161] Relax assert in ApplyEditAndContinue (#64132)

Fixes #64070
---
 src/coreclr/md/enc/metamodelrw.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/coreclr/md/enc/metamodelrw.cpp b/src/coreclr/md/enc/metamodelrw.cpp
index 34fe8b84e95c88..3fde673faa5c43 100644
--- a/src/coreclr/md/enc/metamodelrw.cpp
+++ b/src/coreclr/md/enc/metamodelrw.cpp
@@ -309,16 +309,15 @@ ULONG CMiniMdRW::m_TruncatedEncTables[] =
 ULONG CMiniMdRW::GetTableForToken(      // Table index, or -1.
     mdToken     tkn)                    // Token to find.
 {
-    ULONG       ixTbl;                  // Loop control.
     ULONG       type = TypeFromToken(tkn);
 
     // Get the type -- if a string, no associated table.
     if (type >= mdtString)
         return (ULONG) -1;
     // Table number is same as high-byte of token.
-    ixTbl = type >> 24;
+    ULONG ixTbl = type >> 24;
     // Make sure.
-     _ASSERTE(g_TblIndex[ixTbl].m_Token == type);
+    _ASSERTE(ixTbl < TBL_COUNT);
 
     return ixTbl;
 } // CMiniMdRW::GetTableForToken

From fe622eb8981361d13b4821db66a4326b8daa5138 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Sat, 22 Jan 2022 09:19:39 -0500
Subject: [PATCH 005/161] Disable NJulianRuleTest test crashing in CI (#64142)

---
 src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
index b352a529d6b009..fb7b8292b03f9d 100644
--- a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
+++ b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
@@ -2489,6 +2489,7 @@ public static void GetSystemTimeZones_AllTimeZonesHaveOffsetInValidRange()
             // 0x3E, 0x2C, 0x30, 0x2F, 0x30, 0x2C, 0x4A, 0x33, 0x36, 0x35, 0x2F, 0x32, 0x35, 0x0A
         };
 
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/64134")]
         [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         [PlatformSpecific(TestPlatforms.AnyUnix)]
         [InlineData("<+00>0<+01>,0/0,J365/25", 1, 1, true)]

From 8c1b48040db83aa3c24e654cf3dd9c22fa68d376 Mon Sep 17 00:00:00 2001
From: Floris Westerman <me@floriswesterman.nl>
Date: Sat, 22 Jan 2022 16:44:23 +0100
Subject: [PATCH 006/161] Updating unit tests for
 DirectoryServices.AccountManagement (#56670)

Removing old, redundant unit tests that were actually never executed

Migrating old tests to new test infrastructure with configurable LDAP/AD
connections
---
 .../tests/AccountManagementTests.cs           |  73 ++++++++-
 .../tests/ComputerPrincipalTest.cs            |  83 ----------
 .../tests/ExtendedUserPrincipal.cs            |  36 -----
 .../tests/GroupPrincipalTest.cs               |  68 ---------
 .../tests/PrincipalTest.cs                    | 143 ------------------
 ...oryServices.AccountManagement.Tests.csproj |   8 +-
 .../tests/UserPrincipalTest.cs                |  32 ----
 7 files changed, 70 insertions(+), 373 deletions(-)
 delete mode 100644 src/libraries/System.DirectoryServices.AccountManagement/tests/ComputerPrincipalTest.cs
 delete mode 100644 src/libraries/System.DirectoryServices.AccountManagement/tests/ExtendedUserPrincipal.cs
 delete mode 100644 src/libraries/System.DirectoryServices.AccountManagement/tests/GroupPrincipalTest.cs
 delete mode 100644 src/libraries/System.DirectoryServices.AccountManagement/tests/PrincipalTest.cs
 delete mode 100644 src/libraries/System.DirectoryServices.AccountManagement/tests/UserPrincipalTest.cs

diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs b/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs
index 10dde4837cc6d3..33de32cb836c09 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs
+++ b/src/libraries/System.DirectoryServices.AccountManagement/tests/AccountManagementTests.cs
@@ -17,6 +17,42 @@ public class AccountManagementTests
         internal static bool IsActiveDirectoryServer => IsLdapConfigurationExist && LdapConfiguration.Configuration.IsActiveDirectoryServer;
         internal static bool IsDomainJoinedClient => !Environment.MachineName.Equals(Environment.UserDomainName, StringComparison.OrdinalIgnoreCase);
 
+        [Fact]
+        public void TestConstructors()
+        {
+            using var context = new PrincipalContext(ContextType.Machine);
+
+            using (var principal = new ComputerPrincipal(context))
+            {
+                Assert.Same(context, principal.Context);
+                Assert.Empty(principal.ServicePrincipalNames);
+                Assert.Equal(ContextType.Machine, principal.ContextType);
+            }
+            Assert.Throws<ArgumentException>(() => new ComputerPrincipal(null));
+            Assert.Throws<ArgumentException>(() => new ComputerPrincipal(null, "samAccountName", "password", true));
+            Assert.Throws<ArgumentException>(() => new ComputerPrincipal(context, null, "password", true));
+            Assert.Throws<ArgumentException>(() => new ComputerPrincipal(context, "samAccountName", null, true));
+
+            using (var principal = new UserPrincipal(context))
+            {
+                Assert.Same(context, principal.Context);
+                Assert.Equal(ContextType.Machine, principal.ContextType);
+            }
+            Assert.Throws<ArgumentException>(() => new UserPrincipal(null));
+            Assert.Throws<ArgumentException>(() => new UserPrincipal(null, "samAccountName", "password", true));
+            Assert.Throws<ArgumentException>(() => new UserPrincipal(context, null, "password", true));
+            Assert.Throws<ArgumentException>(() => new UserPrincipal(context, "samAccountName", null, true));
+
+            using (var principal = new GroupPrincipal(context))
+            {
+                Assert.Same(context, principal.Context);
+                Assert.Equal(ContextType.Machine, principal.ContextType);
+            }
+            Assert.Throws<ArgumentException>(() => new GroupPrincipal(null));
+            Assert.Throws<ArgumentException>(() => new GroupPrincipal(null, "samAccountName"));
+            Assert.Throws<ArgumentException>(() => new GroupPrincipal(context, null));
+        }
+
         [ConditionalFact(nameof(IsActiveDirectoryServer))]
         public void TestCurrentUser()
         {
@@ -24,7 +60,7 @@ public void TestCurrentUser()
             using (UserPrincipal p = FindUser(LdapConfiguration.Configuration.UserNameWithNoDomain, context))
             {
                 Assert.NotNull(p);
-                Assert.Equal(LdapConfiguration.Configuration.UserNameWithNoDomain, p.Name);
+                Assert.Equal(LdapConfiguration.Configuration.UserNameWithNoDomain, p.SamAccountName);
             }
         }
 
@@ -35,6 +71,7 @@ public void TestCurrentUserContext()
             using (UserPrincipal p = FindUser(LdapConfiguration.Configuration.UserNameWithNoDomain, context))
             using (UserPrincipal cu = UserPrincipal.Current)
             {
+                Assert.NotNull(cu);
                 Assert.NotEqual(cu.Context.Name, p.Context.Name);
             }
         }
@@ -46,7 +83,7 @@ public void TestCurrentUserUsingSearchFilter()
             using (UserPrincipal p = FindUserUsingFilter(LdapConfiguration.Configuration.UserNameWithNoDomain, context))
             {
                 Assert.NotNull(p);
-                Assert.Equal(LdapConfiguration.Configuration.UserNameWithNoDomain, p.Name);
+                Assert.Equal(LdapConfiguration.Configuration.UserNameWithNoDomain, p.SamAccountName);
             }
         }
 
@@ -279,6 +316,27 @@ public void TestNegativeCases()
             }
         }
 
+        [ConditionalFact(nameof(IsActiveDirectoryServer))]
+        public void TestInvalidSaves()
+        {
+            UserData u1 = UserData.GenerateUserData("CoreFxUser9");
+
+            DeleteUser(u1.Name);
+
+            try
+            {
+                using var context = DomainContext;
+                using var user = new UserPrincipal(context, u1.Name, u1.Password, true);
+                
+                Assert.Throws<InvalidOperationException>(() => user.Save(null));
+                Assert.Throws<InvalidOperationException>(() => user.Save(new PrincipalContext(ContextType.Machine)));
+            }
+            finally
+            {
+                DeleteUser(u1.Name);
+            }
+        }
+
         [ConditionalFact(nameof(IsActiveDirectoryServer))]
         public void TestComputerContext()
         {
@@ -307,6 +365,13 @@ public void TestComputerContext()
             }
         }
 
+        [ConditionalFact(nameof(IsActiveDirectoryServer))]
+        public void TestComputerNegativeCases()
+        {
+            using var context = DomainContext;
+
+        }
+
         [ConditionalFact(nameof(IsActiveDirectoryServer))]
         public void TestUpdateUserAndGroupData()
         {
@@ -591,7 +656,7 @@ private GroupPrincipal FindGroup(string groupName, PrincipalContext context)
 
         private UserPrincipal FindUser(string userName, PrincipalContext context)
         {
-            return UserPrincipal.FindByIdentity(context, IdentityType.Name, userName);
+            return UserPrincipal.FindByIdentity(context, IdentityType.SamAccountName, userName);
         }
 
         private CustomUserPrincipal FindCustomUser(string userName, PrincipalContext context)
@@ -723,7 +788,7 @@ public CustomFilter(Principal p) : base(p) { }
 
         public void SetFilter(string userName)
         {
-            this.AdvancedFilterSet("cn", userName, typeof(string), MatchType.Equals);
+            this.AdvancedFilterSet("samAccountName", userName, typeof(string), MatchType.Equals);
         }
     }
 }
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/ComputerPrincipalTest.cs b/src/libraries/System.DirectoryServices.AccountManagement/tests/ComputerPrincipalTest.cs
deleted file mode 100644
index ce6b8cf70565b9..00000000000000
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/ComputerPrincipalTest.cs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit;
-
-namespace System.DirectoryServices.AccountManagement.Tests
-{
-    public class ComputerPrincipalTest : PrincipalTest
-    {
-        [Fact]
-        public void Ctor_Context()
-        {
-            var context = new PrincipalContext(ContextType.Machine);
-            var principal = new ComputerPrincipal(context);
-            Assert.Same(context, principal.Context);
-            Assert.Empty(principal.ServicePrincipalNames);
-        }
-
-        [Fact]
-        public void Ctor_NullContext_ThrowsArgumentException()
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => new ComputerPrincipal(null));
-            AssertExtensions.Throws<ArgumentException>(null, () => new ComputerPrincipal(null, "samAccountName", "password", enabled: true));
-        }
-
-        [Fact]
-        public void Ctor_NullSamAccountName_ThrowsArgumentException()
-        {
-            var context = new PrincipalContext(ContextType.Machine);
-            AssertExtensions.Throws<ArgumentException>(null, () => new ComputerPrincipal(context, null, "password", enabled: true));
-        }
-
-        [Fact]
-        public void Ctor_EmptySamAccountName_ThrowsArgumentNullException()
-        {
-            var context = new PrincipalContext(ContextType.Machine);
-            AssertExtensions.Throws<ArgumentNullException>("value", null, () => new ComputerPrincipal(context, string.Empty, "password", enabled: true));
-        }
-
-        [Fact]
-        public void Ctor_NullPassword_ThrowsArgumentException()
-        {
-            var context = new PrincipalContext(ContextType.Machine);
-            AssertExtensions.Throws<ArgumentException>(null, () => new ComputerPrincipal(context, "samAccountName", null, enabled: true));
-        }
-
-        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsNanoNorServerCore), nameof(PlatformDetection.IsNotWindowsIoTCore))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/34442", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
-        public void Ctor_MachineContext_NoException()
-        {
-            var context = new PrincipalContext(ContextType.Machine);
-            var principal = new ComputerPrincipal(context, "samAccountName", "password", enabled: true);
-            Assert.Equal(ContextType.Machine, principal.ContextType);
-        }
-
-        [Fact]
-        public void ComputerPrincipalConstructorTest()
-        {
-            if (DomainContext == null)
-            {
-                return;
-            }
-
-            ComputerPrincipal computer = new ComputerPrincipal(DomainContext);
-            computer.Dispose();
-        }
-
-        public override Principal CreatePrincipal(PrincipalContext context, string name)
-        {
-            return new ComputerPrincipal(context) { Name = name };
-        }
-
-        public override Principal CreateExtendedPrincipal(PrincipalContext context, string name)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override Principal FindExtendedPrincipal(PrincipalContext context, string name)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/ExtendedUserPrincipal.cs b/src/libraries/System.DirectoryServices.AccountManagement/tests/ExtendedUserPrincipal.cs
deleted file mode 100644
index 7f378a13acf430..00000000000000
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/ExtendedUserPrincipal.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.DirectoryServices.AccountManagement.Tests
-{
-    [DirectoryRdnPrefix("CN")]
-    [DirectoryObjectClass("User")]
-    public class ExtendedUserPrincipal : UserPrincipal, IExtendedPrincipalTest
-    {
-        public ExtendedUserPrincipal(PrincipalContext context) : base(context) { }
-
-        public static new ExtendedUserPrincipal FindByIdentity(PrincipalContext context,string identityValue)
-        {
-            return (ExtendedUserPrincipal)FindByIdentityWithType(context, typeof(ExtendedUserPrincipal), identityValue);
-        }
-
-        [DirectoryProperty("jpegPhoto")]
-        public byte[] ByteArrayExtension
-        {
-            get => (byte[])ExtensionGet("jpegPhoto")[0];
-            set => ExtensionSet("jpegPhoto", value);
-        }
-
-        public object ObjectExtension
-        {
-            get => throw new NotImplementedException();
-            set => throw new NotImplementedException();
-        }
-
-        public object[] ObjectArrayExtension
-        {
-            get => throw new NotImplementedException();
-            set => throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/GroupPrincipalTest.cs b/src/libraries/System.DirectoryServices.AccountManagement/tests/GroupPrincipalTest.cs
deleted file mode 100644
index 8817afbddd186a..00000000000000
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/GroupPrincipalTest.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit;
-
-namespace System.DirectoryServices.AccountManagement.Tests
-{
-    public class GroupPrincipalTest : PrincipalTest
-    {
-        [Fact]
-        public void GroupPrincipalConstructorTest()
-        {
-            if (DomainContext == null)
-            {
-                return;
-            }
-
-            GroupPrincipal group = new GroupPrincipal(DomainContext);
-            group.Dispose();
-        }
-
-        public override Principal CreatePrincipal(PrincipalContext context, string name)
-        {
-            return new GroupPrincipal(context, name);
-        }
-
-        [Fact]
-        public void IsMemberOfTest()
-        {
-            if (DomainContext == null)
-            {
-                return;
-            }
-
-            using (GroupPrincipal group = GroupPrincipal.FindByIdentity(DomainContext, "TestLargeGroup"))
-            {
-                Assert.True(UserPrincipal.FindByIdentity(DomainContext, "user1499-LargeGroup").IsMemberOf(group));
-                Assert.True(UserPrincipal.FindByIdentity(DomainContext, "user1500-LargeGroup").IsMemberOf(group));
-                Assert.True(UserPrincipal.FindByIdentity(DomainContext, "user1501-LargeGroup").IsMemberOf(group));
-                Assert.True(UserPrincipal.FindByIdentity(DomainContext, "user3000-LargeGroup").IsMemberOf(group));
-                Assert.True(UserPrincipal.FindByIdentity(DomainContext, "user3001-LargeGroup").IsMemberOf(group));
-                Assert.False(UserPrincipal.FindByIdentity(DomainContext, "userNotInLargeGroup").IsMemberOf(group));
-            }
-        }
-
-        private void CreateManyUsersInGroup(GroupPrincipal group)
-        {
-            for (int i = 1; i < 3002; i++)
-            {
-                string name = $"user{i:0000}-LargeGroup";
-                UserPrincipal user = new UserPrincipal(DomainContext, name, "Adrumble@6", false);
-                user.Save();
-                group.Members.Add(user);
-            }
-            group.Save();
-        }
-
-        public override Principal CreateExtendedPrincipal(PrincipalContext context, string name)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override Principal FindExtendedPrincipal(PrincipalContext context, string name)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/PrincipalTest.cs b/src/libraries/System.DirectoryServices.AccountManagement/tests/PrincipalTest.cs
deleted file mode 100644
index a0078001f74f46..00000000000000
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/PrincipalTest.cs
+++ /dev/null
@@ -1,143 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Generic;
-using System.Security.Principal;
-using Xunit;
-
-namespace System.DirectoryServices.AccountManagement.Tests
-{
-    public abstract class PrincipalTest : IDisposable
-    {
-        public PrincipalContext DomainContext { get; private set; }
-
-        public PrincipalTest() => RefreshContext();
-
-        private void RefreshContext()
-        {
-            string username = "Administrator";
-            string password = Environment.GetEnvironmentVariable("TESTPASSWORD");
-            string OU = "Tests";
-            string baseDomain = WindowsIdentity.GetCurrent().Name.Split(new char[] { '\\' })[1] + "-TEST";
-            string domain = $"{baseDomain}.nttest.microsoft.com";
-            string container = $"ou={OU},dc={baseDomain},dc=nttest,dc=microsoft,dc=com";
-            DomainContext?.Dispose();
-            try
-            {
-                DomainContext = new PrincipalContext(ContextType.Domain, domain, container, username, password);
-            }
-            catch
-            {
-            }
-        }
-
-        public void Dispose() => DomainContext?.Dispose();
-
-        [Fact]
-        public void AddExistingPrincipal()
-        {
-            if (DomainContext == null)
-            {
-                return;
-            }
-
-            // use new GUID for the user name so we be sure this user does not exist yet
-            string name = Guid.NewGuid().ToString();
-            using (Principal principal = CreatePrincipal(DomainContext, name))
-            {
-                principal.Save();
-            }
-
-            Assert.NotNull(Principal.FindByIdentity(DomainContext, name));
-
-            // this previously caused the user to be deleted. it is still expected to throw an exception, but not delete the user
-            bool exceptionThrown = false;
-            try
-            {
-                using (Principal principal = CreatePrincipal(DomainContext, name))
-                {
-                    principal.Save();
-                }
-            }
-            catch (PrincipalExistsException)
-            {
-                exceptionThrown = true;
-            }
-
-            // validate that we correctly throw an exception when trying to add an existing principal
-            Assert.True(exceptionThrown);
-
-            // validate that we did not delete incorrectly delete the first principal
-            using (Principal principal2 = Principal.FindByIdentity(DomainContext, name))
-            {
-                Assert.NotNull(principal2);
-
-                // explicitly delete the user and check it was really deleted
-                principal2.Delete();
-            }
-
-            // ensure we cleaned up the test principal
-            Assert.Null(Principal.FindByIdentity(DomainContext, name));
-        }
-
-        [Fact]
-        public void TestExtendedPrincipal()
-        {
-            if (DomainContext == null)
-            {
-                return;
-            }
-
-            string name = Guid.NewGuid().ToString();
-            byte[] writtenArray = new byte[] { 10, 20, 30 };
-            using (Principal principal = CreateExtendedPrincipal(DomainContext, name))
-            {
-                IExtendedPrincipalTest extendedPrincipal = (IExtendedPrincipalTest)principal;
-                extendedPrincipal.ByteArrayExtension = writtenArray;
-                principal.Save();
-            }
-
-            RefreshContext();
-            using (Principal principal = FindExtendedPrincipal(DomainContext, name))
-            {
-                IExtendedPrincipalTest extendedPrincipal = (IExtendedPrincipalTest)principal;
-                byte[] readArray = extendedPrincipal.ByteArrayExtension;
-                principal.Delete();
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TestDebuggerAttributes_Inputs))]
-        public void Save_ThrowsInvalidOperationException(PrincipalContext context)
-        {
-            if (DomainContext == null)
-            {
-                return;
-            }
-
-            using (Principal principal = CreateExtendedPrincipal(DomainContext, Guid.NewGuid().ToString()))
-            {
-                Assert.Throws<InvalidOperationException>(() => principal.Save(context));
-            }
-        }
-
-        public static IEnumerable<object[]> TestDebuggerAttributes_Inputs()
-        {
-            yield return new object[] { null };
-            yield return new object[] { new PrincipalContext(ContextType.Machine) };
-        }
-
-        public abstract Principal CreatePrincipal(PrincipalContext context, string name);
-
-        public abstract Principal CreateExtendedPrincipal(PrincipalContext context, string name);
-
-        public abstract Principal FindExtendedPrincipal(PrincipalContext context, string name);
-    }
-
-    public interface IExtendedPrincipalTest
-    {
-        object ObjectExtension { get; set; }
-        byte[] ByteArrayExtension { get; set; }
-        object[] ObjectArrayExtension { get; set; }
-    }
-}
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/System.DirectoryServices.AccountManagement.Tests.csproj b/src/libraries/System.DirectoryServices.AccountManagement/tests/System.DirectoryServices.AccountManagement.Tests.csproj
index 6ee1a6b7217ba6..0bb24c8eadd87d 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/System.DirectoryServices.AccountManagement.Tests.csproj
+++ b/src/libraries/System.DirectoryServices.AccountManagement/tests/System.DirectoryServices.AccountManagement.Tests.csproj
@@ -3,15 +3,9 @@
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;net48</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="ComputerPrincipalTest.cs" />
-    <Compile Include="ExtendedUserPrincipal.cs" />
-    <Compile Include="GroupPrincipalTest.cs" />
-    <Compile Include="PrincipalTest.cs" />
     <Compile Include="PrincipalContextTests.cs" />
-    <Compile Include="UserPrincipalTest.cs" />
     <Compile Include="AccountManagementTests.cs" />
-    <Compile Include="$(CommonTestPath)System\DirectoryServices\LdapConfiguration.cs"
-             Link="Common\DirectoryServices\LdapConfiguration.cs" />
+    <Compile Include="$(CommonTestPath)System\DirectoryServices\LdapConfiguration.cs" Link="Common\DirectoryServices\LdapConfiguration.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="$(CommonTestPath)System\DirectoryServices\LDAP.Configuration.xml">
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/tests/UserPrincipalTest.cs b/src/libraries/System.DirectoryServices.AccountManagement/tests/UserPrincipalTest.cs
deleted file mode 100644
index 53b99ab5c939cc..00000000000000
--- a/src/libraries/System.DirectoryServices.AccountManagement/tests/UserPrincipalTest.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Security.Principal;
-using Xunit;
-
-namespace System.DirectoryServices.AccountManagement.Tests
-{
-    public class UserPrincipalTest : PrincipalTest
-    {
-        public override Principal CreatePrincipal(PrincipalContext context, string name)
-        {
-            return new UserPrincipal(context) { Name = name };
-        }
-
-        public override Principal CreateExtendedPrincipal(PrincipalContext context, string name)
-        {
-            return new ExtendedUserPrincipal(context) { Name = name };
-        }
-
-        public override Principal FindExtendedPrincipal(PrincipalContext context, string name)
-        {
-            return ExtendedUserPrincipal.FindByIdentity(context, name);
-        }
-
-        public void UserPrincipalConstructorTest()
-        {
-            UserPrincipal user = new UserPrincipal(DomainContext);
-            user.Dispose();
-        }
-    }
-}

From feb25b01385242beb804b48f4954dbda62d3d54f Mon Sep 17 00:00:00 2001
From: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date: Sat, 22 Jan 2022 22:24:54 +0200
Subject: [PATCH 007/161] Fix MultiByteToWideChar call in pal (#64146)

---
 src/coreclr/pal/src/init/pal.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/coreclr/pal/src/init/pal.cpp b/src/coreclr/pal/src/init/pal.cpp
index 5469b4bebd483a..951680114d8868 100644
--- a/src/coreclr/pal/src/init/pal.cpp
+++ b/src/coreclr/pal/src/init/pal.cpp
@@ -1242,7 +1242,7 @@ static LPWSTR INIT_FormatCommandLine (int argc, const char * const *argv)
         return NULL;
     }
 
-    if(!MultiByteToWideChar(CP_ACP, 0,command_line, i, retval, i))
+    if(!MultiByteToWideChar(CP_ACP, 0,command_line, -1, retval, i))
     {
         ASSERT("MultiByteToWideChar failure\n");
         free(retval);

From 8d2268a5323f261d63b4b288fc96c2daa34fc6cf Mon Sep 17 00:00:00 2001
From: Vladimir Sadov <vsadov@microsoft.com>
Date: Sat, 22 Jan 2022 14:57:43 -0800
Subject: [PATCH 008/161] Extra tests for assembly name parser. (#64022)

* Dead code in native assembly name parsing

* disallow `\u` escaping in assembly names

* misc cleanup

* forward slash is illegal escaped or not

* ignore "language" attribute in assembly name ("culture" must be used)

* duplicate attributes are ok if unrecognized (just add tests)

* drop support for "custom" blob attribute

* drop support for publickey[token]=neutral ("null" must be used)

* ignore unknown assembly name attributes in mono (compat)

* disallow \0 anywhere in the assembly name

* disallow \0 in assembly names on mono (compat)

* only check for embedded nulls when parsing

* fix mono build

* make GCC happy

* couple test scenarios for publickey vs. publickeytoken (CoreRT parser might trip on these)

* produce errors on duplicate known attributes in mono
---
 src/coreclr/binder/inc/assemblyidentity.hpp   |   5 -
 src/coreclr/binder/inc/stringlexer.hpp        |  16 +-
 src/coreclr/binder/inc/stringlexer.inl        | 164 +++---------------
 .../binder/inc/textualidentityparser.hpp      |  11 +-
 src/coreclr/binder/stringlexer.cpp            |  28 ++-
 src/coreclr/binder/textualidentityparser.cpp  |  71 +-------
 src/coreclr/vm/assemblyspec.cpp               |   8 +-
 src/coreclr/vm/assemblyspec.hpp               |   2 +-
 .../tests/AssemblyNameTests.cs                |  38 ++++
 .../System/Reflection/AssemblyName.Mono.cs    |   3 +
 src/mono/mono/metadata/assembly.c             |  29 ++--
 11 files changed, 137 insertions(+), 238 deletions(-)

diff --git a/src/coreclr/binder/inc/assemblyidentity.hpp b/src/coreclr/binder/inc/assemblyidentity.hpp
index cc0916c8780afa..ef4768d3b8cd9b 100644
--- a/src/coreclr/binder/inc/assemblyidentity.hpp
+++ b/src/coreclr/binder/inc/assemblyidentity.hpp
@@ -30,12 +30,9 @@ namespace BINDER_SPACE
             IDENTITY_FLAG_PUBLIC_KEY_TOKEN       = 0x004,
             IDENTITY_FLAG_PUBLIC_KEY             = 0x008,
             IDENTITY_FLAG_CULTURE                = 0x010,
-            IDENTITY_FLAG_LANGUAGE               = 0x020,
             IDENTITY_FLAG_PROCESSOR_ARCHITECTURE = 0x040,
             IDENTITY_FLAG_RETARGETABLE           = 0x080,
             IDENTITY_FLAG_PUBLIC_KEY_TOKEN_NULL  = 0x100,
-            IDENTITY_FLAG_CUSTOM                 = 0x200,
-            IDENTITY_FLAG_CUSTOM_NULL            = 0x400,
             IDENTITY_FLAG_CONTENT_TYPE           = 0x800,
             IDENTITY_FLAG_FULL_NAME              = (IDENTITY_FLAG_SIMPLE_NAME |
                                                     IDENTITY_FLAG_VERSION)
@@ -50,7 +47,6 @@ namespace BINDER_SPACE
             // Need to pre-populate SBuffers because of bogus asserts
             static const BYTE byteArr[] = { 0 };
             m_publicKeyOrTokenBLOB.SetImmutable(byteArr, sizeof(byteArr));
-            m_customBLOB.SetImmutable(byteArr, sizeof(byteArr));
         }
         ~AssemblyIdentity()
         {
@@ -83,7 +79,6 @@ namespace BINDER_SPACE
         SBuffer             m_publicKeyOrTokenBLOB;
         PEKIND              m_kProcessorArchitecture;
         AssemblyContentType m_kContentType;
-        SBuffer             m_customBLOB;
         DWORD               m_dwIdentityFlags;
     };
 
diff --git a/src/coreclr/binder/inc/stringlexer.hpp b/src/coreclr/binder/inc/stringlexer.hpp
index 41af7e7baa18d7..f08e046982c566 100644
--- a/src/coreclr/binder/inc/stringlexer.hpp
+++ b/src/coreclr/binder/inc/stringlexer.hpp
@@ -55,32 +55,28 @@ namespace BINDER_SPACE
         inline StringLexer();
         inline ~StringLexer();
 
-        inline void Init(SString &inputString, BOOL fSupportEscaping);
+        inline void Init(SString &inputString);
 
         static inline BOOL IsWhitespace(WCHAR wcChar);
         static inline BOOL IsEOS(WCHAR wcChar);
         static inline BOOL IsQuoteCharacter(WCHAR wcChar);
 
-        virtual BOOL IsSeparatorChar(WCHAR wcChar) = NULL;
-        virtual LEXEME_TYPE GetLexemeType(WCHAR wcChar) = NULL;
+        BOOL IsSeparatorChar(WCHAR wcChar);
+        LEXEME_TYPE GetLexemeType(WCHAR wcChar);
 
     protected:
         static const WCHAR INVALID_CHARACTER = -1;
 
-        LEXEME_TYPE GetNextLexeme(SString &currentString, BOOL fPermitUnescapedQuotes = FALSE);
+        LEXEME_TYPE GetNextLexeme(SString &currentString);
 
         inline WCHAR PopCharacter(BOOL *pfIsEscaped);
         inline void PushCharacter(WCHAR wcCurrentChar,
                                   BOOL fIsEscaped);
 
         inline WCHAR GetRawCharacter();
-        inline void PushRawCharacter();
-        inline WCHAR DecodeUTF16Character();
         inline WCHAR GetNextCharacter(BOOL *pfIsEscaped);
 
-        inline WCHAR ParseUnicode();
-        LEXEME_TYPE ParseString(SString &currentString,
-                                BOOL     fPermitUnescapeQuotes);
+        LEXEME_TYPE ParseString(SString &currentString);
 
         void TrimTrailingWhiteSpaces(SString &currentString);
 
@@ -89,8 +85,6 @@ namespace BINDER_SPACE
 
         WCHAR m_wcCurrentChar;
         BOOL m_fCurrentCharIsEscaped;
-        BOOL m_fSupportEscaping;
-        BOOL m_fReadRawCharacter;
     };
 
 #include "stringlexer.inl"
diff --git a/src/coreclr/binder/inc/stringlexer.inl b/src/coreclr/binder/inc/stringlexer.inl
index bfe4bddeaa4c18..42f7f73ed0bbc2 100644
--- a/src/coreclr/binder/inc/stringlexer.inl
+++ b/src/coreclr/binder/inc/stringlexer.inl
@@ -25,12 +25,10 @@ StringLexer::~StringLexer()
     // Nothing to do here
 }
 
-void StringLexer::Init(SString &inputString, BOOL fSupportEscaping)
+void StringLexer::Init(SString &inputString)
 {
     m_cursor = inputString.Begin();
     m_end = inputString.End();
-    m_fSupportEscaping = fSupportEscaping;
-    m_fReadRawCharacter = FALSE;
 }
 
 BOOL StringLexer::IsWhitespace(WCHAR wcChar)
@@ -55,6 +53,7 @@ WCHAR StringLexer::PopCharacter(BOOL *pfIsEscaped)
     {
         m_wcCurrentChar = INVALID_CHARACTER;
         *pfIsEscaped = m_fCurrentCharIsEscaped;
+        m_cursor++;
     }
     else
     {
@@ -71,172 +70,63 @@ void StringLexer::PushCharacter(WCHAR wcCurrentChar,
 
     m_wcCurrentChar = wcCurrentChar;
     m_fCurrentCharIsEscaped = fIsEscaped;
+    m_cursor--;
 }
 
 WCHAR StringLexer::GetRawCharacter()
 {
     WCHAR wcCurrentChar = 0;
 
-    if (m_cursor <= m_end)
+    if (m_cursor < m_end)
     {
         wcCurrentChar = m_cursor[0];
-        m_fReadRawCharacter = TRUE;
         m_cursor++;
-    }
-    else
-    {
-        m_fReadRawCharacter = FALSE;
-    }
-
-    return wcCurrentChar;
-}
-
-void StringLexer::PushRawCharacter()
-{
-    if (m_fReadRawCharacter)
-    {
-        m_cursor--;
-        m_fReadRawCharacter = FALSE;
-    }
-}
 
-WCHAR StringLexer::DecodeUTF16Character()
-{
-    // See http://www.ietf.org/rfc/rfc2781.txt for details on UTF-16 encoding.
-
-    WCHAR wcCurrentChar = 0;
-    SCOUNT_T nCharacters = m_end - m_cursor + 1;
-    WCHAR wcChar1 = GetRawCharacter();
-
-    if (wcChar1 < 0xd800)
-    {
-        wcCurrentChar = wcChar1;
+        // do not allow \0 anywhere in the string.
+        if (wcCurrentChar == 0)
+        {
+            wcCurrentChar = INVALID_CHARACTER;
+        }
     }
     else
     {
-        // StringLexer is not designed to handle UTF-16 characters beyond the Basic Multilingual Plane,
-        // since it stores all characters in 16-bit WCHARs.
-        // However, since the vast majority of the time, we (Microsoft) produce the manifests,
-        // this is likely a non-scenario, as the other Unicode planes would never be used in practice.
-
-        if (wcChar1 <= 0xdbff) // 0xd800 - 0xdbff indicates the first WCHAR of a surrogate pair
-        {
-            if (nCharacters >= 2)
-            {
-                GetRawCharacter(); // Skip the second WCHAR of the surrogate pair
-            }
-        }
-        // Otherwise, the character is either in the 0xdc00 - 0xdfff range, indicating the second WCHAR of a surrogate pair,
-        // or in the 0xE000 - 0xFFFF range, which has within it ranges of invalid characters, and which we conservatively treat
-        // as invalid.
-
-        wcCurrentChar = INVALID_CHARACTER;
+        // EOS
+        wcCurrentChar = 0;
     }
 
     return wcCurrentChar;
 }
 
-
 WCHAR StringLexer::GetNextCharacter(BOOL *pfIsEscaped)
 {
     *pfIsEscaped = FALSE;
 
-    WCHAR wcCurrentChar = GetRawCharacter(); // DecodeUTF16Character()
+    WCHAR wcCurrentChar = GetRawCharacter();
     if (wcCurrentChar == L'\\')
     {
-        WCHAR wcTempChar = GetRawCharacter(); // DecodeUTF16Character()
+        WCHAR wcTempChar = GetRawCharacter();
 
-        if (m_fSupportEscaping)
-        {
-            // Handle standard escapes
-            switch (wcTempChar)
-            {
-            case L'"':
-            case L'\'':
-            case L',':
-            case L'\\':
-            case L'/':
-            case L'=':
-                break;
-            case L't':
-                wcTempChar = 9;
-                break;
-            case L'n':
-                wcTempChar = 10;
-                break;
-            case L'r':
-                wcTempChar = 13;
-                break;
-            case L'u':
-                wcTempChar = ParseUnicode();
-                break;
-            default:
-                return INVALID_CHARACTER;
-            }
-
-            *pfIsEscaped = TRUE;
-            wcCurrentChar = wcTempChar;
-        }
-        else
-        {
-            // Do not handle escapes except for quotes
-            switch (wcTempChar)
-            {
-            case L'"':
-            case L'\'':
-                *pfIsEscaped = TRUE;
-                wcCurrentChar = wcTempChar;
-                break;
-            default:
-                PushRawCharacter();
-                break;
-            }
-        }
-    }
-
-    return wcCurrentChar;
-}
-
-WCHAR StringLexer::ParseUnicode()
-{
-    int nCharacters = 0;
-    WCHAR wcUnicodeChar = 0;
-
-    for(;;)
-    {
-        WCHAR wcCurrentChar = DecodeUTF16Character();
-        nCharacters++;
-
-        if (wcCurrentChar == L';')
+        // Handle standard escapes
+        switch (wcTempChar)
         {
+        case L'"':
+        case L'\'':
+        case L',':
+        case L'\\':
+        case L'=':
+        case L't':
+        case L'n':
+        case L'r':
             break;
-        }
-        else if ((wcCurrentChar == INVALID_CHARACTER) || (nCharacters >= 9))
-        {
+        default:
             return INVALID_CHARACTER;
         }
 
-        wcUnicodeChar <<= 4;
-
-        if ((wcCurrentChar >= L'0') && (wcCurrentChar <= L'9'))
-        {
-            wcUnicodeChar += (wcCurrentChar - L'0');
-        }
-        else if ((wcCurrentChar >= L'a') && (wcCurrentChar <= L'f'))
-        {
-            wcUnicodeChar += (wcCurrentChar - L'a') + 10;
-        }
-        else if ((wcCurrentChar >= L'A') && (wcCurrentChar <= L'F'))
-        {
-            wcUnicodeChar += (wcCurrentChar - L'A') + 10;
-        }
-        else
-        {
-            return INVALID_CHARACTER;
-        }
+        *pfIsEscaped = TRUE;
+        wcCurrentChar = wcTempChar;
     }
 
-    return wcUnicodeChar;
+    return wcCurrentChar;
 }
 
 #endif
diff --git a/src/coreclr/binder/inc/textualidentityparser.hpp b/src/coreclr/binder/inc/textualidentityparser.hpp
index a5187d254a6522..2b60c3110f37f7 100644
--- a/src/coreclr/binder/inc/textualidentityparser.hpp
+++ b/src/coreclr/binder/inc/textualidentityparser.hpp
@@ -28,12 +28,9 @@ namespace BINDER_SPACE
         TextualIdentityParser(AssemblyIdentity *pAssemblyIdentity);
         ~TextualIdentityParser();
 
-        virtual BOOL IsSeparatorChar(WCHAR wcChar);
-        virtual StringLexer::LEXEME_TYPE GetLexemeType(WCHAR wcChar);
-
         static HRESULT Parse(/* in */  SString           &textualIdentity,
-                             /* out */ AssemblyIdentity *pAssemblyIdentity,
-                             /* in */  BOOL              fPermitUnescapedQuotes = FALSE);
+                             /* out */ AssemblyIdentity *pAssemblyIdentity);
+
         static HRESULT ToString(/* in */  AssemblyIdentity *pAssemblyIdentity,
                                 /* in */  DWORD             dwIdentityFlags,
                                 /* out */ SString          &textualIdentity);
@@ -45,6 +42,7 @@ namespace BINDER_SPACE
                               /* in */  BOOL     fValidateHex,
                               /* in */  BOOL     fIsToken,
                               /* out */ SBuffer &publicKeyOrTokenBLOB);
+
         static void BlobToHex(/* in */  SBuffer &publicKeyOrTokenBLOB,
                               /* out */ SString &publicKeyOrToken);
 
@@ -52,8 +50,7 @@ namespace BINDER_SPACE
                          /* out */ SString &contentString);
 
     protected:
-        BOOL Parse(/* in */  SString &textualIdentity,
-                   /* in */  BOOL     fPermitUnescapedQuotes = FALSE);
+        BOOL Parse(/* in */  SString &textualIdentity);
 
         BOOL PopulateAssemblyIdentity(/* in */ SString &attributeString,
                                       /* in */ SString &valueString);
diff --git a/src/coreclr/binder/stringlexer.cpp b/src/coreclr/binder/stringlexer.cpp
index b6b722fa77ab9f..44ec23e3b517cd 100644
--- a/src/coreclr/binder/stringlexer.cpp
+++ b/src/coreclr/binder/stringlexer.cpp
@@ -19,7 +19,7 @@
 namespace BINDER_SPACE
 {
     StringLexer::LEXEME_TYPE
-    StringLexer::GetNextLexeme(SString &currentString, BOOL fPermitUnescapedQuotes)
+    StringLexer::GetNextLexeme(SString &currentString)
     {
         BOOL fIsEscaped = FALSE;
         WCHAR wcCurrentChar = INVALID_CHARACTER;
@@ -43,11 +43,11 @@ namespace BINDER_SPACE
 
         // First character of string lexeme; push it back
         PushCharacter(wcCurrentChar, fIsEscaped);
-        return ParseString(currentString, fPermitUnescapedQuotes);
+        return ParseString(currentString);
     }
 
     StringLexer::LEXEME_TYPE
-    StringLexer::ParseString(SString &currentString, BOOL fPermitUnescapedQuotes)
+    StringLexer::ParseString(SString &currentString)
     {
         BOOL fIsFirstCharacter = TRUE;
         WCHAR wcCurrentChar = INVALID_CHARACTER;
@@ -99,7 +99,7 @@ namespace BINDER_SPACE
                 break;
             }
 
-            if (!fPermitUnescapedQuotes && !fIsEscaped && IsQuoteCharacter(wcCurrentChar) && !IsQuoteCharacter(wcOpeningQuote))
+            if (!fIsEscaped && IsQuoteCharacter(wcCurrentChar) && !IsQuoteCharacter(wcOpeningQuote))
             {
                 // Unescaped quotes in the middle of the string are an error
                 return LEXEME_TYPE_INVALID;
@@ -147,4 +147,24 @@ namespace BINDER_SPACE
             currentString.Truncate(cursor + 1);
         }
     }
+
+    BOOL StringLexer::IsSeparatorChar(WCHAR wcChar)
+    {
+        return ((wcChar == W(',')) || (wcChar == W('=')));
+    }
+
+    StringLexer::LEXEME_TYPE StringLexer::GetLexemeType(WCHAR wcChar)
+    {
+        switch (wcChar)
+        {
+        case W('='):
+            return LEXEME_TYPE_EQUALS;
+        case W(','):
+            return LEXEME_TYPE_COMMA;
+        case 0:
+            return LEXEME_TYPE_END_OF_STREAM;
+        default:
+            return LEXEME_TYPE_STRING;
+        }
+    }
 };
diff --git a/src/coreclr/binder/textualidentityparser.cpp b/src/coreclr/binder/textualidentityparser.cpp
index f69e0bf66b202b..35587df3cb7e4d 100644
--- a/src/coreclr/binder/textualidentityparser.cpp
+++ b/src/coreclr/binder/textualidentityparser.cpp
@@ -200,30 +200,9 @@ namespace BINDER_SPACE
         // Nothing to do here
     }
 
-    BOOL TextualIdentityParser::IsSeparatorChar(WCHAR wcChar)
-    {
-        return ((wcChar == W(',')) || (wcChar == W('=')));
-    }
-
-    StringLexer::LEXEME_TYPE TextualIdentityParser::GetLexemeType(WCHAR wcChar)
-    {
-        switch (wcChar)
-        {
-        case W('='):
-            return LEXEME_TYPE_EQUALS;
-        case W(','):
-            return LEXEME_TYPE_COMMA;
-        case 0:
-            return LEXEME_TYPE_END_OF_STREAM;
-        default:
-            return LEXEME_TYPE_STRING;
-        }
-    }
-
     /* static */
     HRESULT TextualIdentityParser::Parse(SString          &textualIdentity,
-                                         AssemblyIdentity *pAssemblyIdentity,
-                                         BOOL              fPermitUnescapedQuotes)
+                                         AssemblyIdentity *pAssemblyIdentity)
     {
         HRESULT hr = S_OK;
 
@@ -233,7 +212,7 @@ namespace BINDER_SPACE
         {
             TextualIdentityParser identityParser(pAssemblyIdentity);
 
-            if (!identityParser.Parse(textualIdentity, fPermitUnescapedQuotes))
+            if (!identityParser.Parse(textualIdentity))
             {
                 IF_FAIL_GO(FUSION_E_INVALID_NAME);
             }
@@ -335,18 +314,6 @@ namespace BINDER_SPACE
                 textualIdentity.Append(ContentTypeToString(pAssemblyIdentity->m_kContentType));
             }
 
-            if (AssemblyIdentity::Have(dwIdentityFlags, AssemblyIdentity::IDENTITY_FLAG_CUSTOM))
-            {
-                textualIdentity.Append(W(", Custom="));
-                tmpString.Clear();
-                BlobToHex(pAssemblyIdentity->m_customBLOB, tmpString);
-                textualIdentity.Append(tmpString);
-            }
-            else if (AssemblyIdentity::Have(dwIdentityFlags,
-                                            AssemblyIdentity::IDENTITY_FLAG_CUSTOM_NULL))
-            {
-                textualIdentity.Append(W(", Custom=null"));
-            }
         }
         EX_CATCH_HRESULT(hr);
 
@@ -486,19 +453,19 @@ namespace BINDER_SPACE
         publicKeyOrToken.CloseBuffer(cbPublicKeyOrTokenBLOB * 2);
     }
 
-    BOOL TextualIdentityParser::Parse(SString &textualIdentity, BOOL fPermitUnescapedQuotes)
+    BOOL TextualIdentityParser::Parse(SString &textualIdentity)
     {
         BOOL fIsValid = TRUE;
         SString unicodeTextualIdentity;
 
         // Lexer modifies input string
         textualIdentity.ConvertToUnicode(unicodeTextualIdentity);
-        Init(unicodeTextualIdentity, TRUE /* fSupportEscaping */);
+        Init(unicodeTextualIdentity);
 
         SmallStackSString currentString;
 
         // Identity format is simple name (, attr = value)*
-        GO_IF_NOT_EXPECTED(GetNextLexeme(currentString, fPermitUnescapedQuotes), LEXEME_TYPE_STRING);
+        GO_IF_NOT_EXPECTED(GetNextLexeme(currentString), LEXEME_TYPE_STRING);
         m_pAssemblyIdentity->m_simpleName.Set(currentString);
         m_pAssemblyIdentity->m_simpleName.Normalize();
         m_pAssemblyIdentity->SetHave(AssemblyIdentity::IDENTITY_FLAG_SIMPLE_NAME);
@@ -532,7 +499,7 @@ namespace BINDER_SPACE
 
         // Lexer modifies input string
         textualString.ConvertToUnicode(unicodeTextualString);
-        Init(unicodeTextualString, TRUE /* fSupportEscaping */);
+        Init(unicodeTextualString);
 
         SmallStackSString currentString;
         GO_IF_NOT_EXPECTED(GetNextLexeme(currentString), LEXEME_TYPE_STRING);
@@ -549,8 +516,7 @@ namespace BINDER_SPACE
     {
         BOOL fIsValid = TRUE;
 
-        if (EqualsCaseInsensitive(attributeString, W("culture")) ||
-            EqualsCaseInsensitive(attributeString, W("language")))
+        if (EqualsCaseInsensitive(attributeString, W("culture")))
         {
             GO_IF_SEEN(AssemblyIdentity::IDENTITY_FLAG_CULTURE);
             GO_IF_WILDCARD(valueString);
@@ -586,8 +552,7 @@ namespace BINDER_SPACE
             GO_IF_SEEN(AssemblyIdentity::IDENTITY_FLAG_PUBLIC_KEY_TOKEN);
             GO_IF_WILDCARD(valueString);
 
-            if (!EqualsCaseInsensitive(valueString, W("null")) &&
-                !EqualsCaseInsensitive(valueString, W("neutral")))
+            if (!EqualsCaseInsensitive(valueString, W("null")))
             {
                 GO_IF_VALIDATE_FAILED(ValidatePublicKeyToken,
                                       AssemblyIdentity::IDENTITY_FLAG_PUBLIC_KEY_TOKEN);
@@ -606,8 +571,7 @@ namespace BINDER_SPACE
             GO_IF_SEEN(AssemblyIdentity::IDENTITY_FLAG_PUBLIC_KEY_TOKEN);
             GO_IF_SEEN(AssemblyIdentity::IDENTITY_FLAG_PUBLIC_KEY);
 
-            if (!EqualsCaseInsensitive(valueString, W("null")) &&
-                !EqualsCaseInsensitive(valueString, W("neutral")))
+            if (!EqualsCaseInsensitive(valueString, W("null")))
             {
                 GO_IF_VALIDATE_FAILED(ValidatePublicKey, AssemblyIdentity::IDENTITY_FLAG_PUBLIC_KEY);
                 HexToBlob(valueString,
@@ -661,23 +625,6 @@ namespace BINDER_SPACE
                 fIsValid = FALSE;
             }
         }
-        else if (EqualsCaseInsensitive(attributeString, W("custom")))
-        {
-            GO_IF_SEEN(AssemblyIdentity::IDENTITY_FLAG_CUSTOM);
-
-            if (EqualsCaseInsensitive(valueString, W("null")))
-            {
-                m_pAssemblyIdentity->SetHave(AssemblyIdentity::IDENTITY_FLAG_CUSTOM_NULL);
-            }
-            else
-            {
-                GO_IF_VALIDATE_FAILED(ValidateHex, AssemblyIdentity::IDENTITY_FLAG_CUSTOM);
-                HexToBlob(valueString,
-                          FALSE /* fValidateHex */,
-                          FALSE /* fIsToken */,
-                          m_pAssemblyIdentity->m_customBLOB);
-            }
-        }
 
     Exit:
         return fIsValid;
diff --git a/src/coreclr/vm/assemblyspec.cpp b/src/coreclr/vm/assemblyspec.cpp
index dfbee7152df19a..0cea7dc7121070 100644
--- a/src/coreclr/vm/assemblyspec.cpp
+++ b/src/coreclr/vm/assemblyspec.cpp
@@ -271,6 +271,11 @@ HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF*
         WCHAR* pString;
         int    iString;
         ((STRINGREF) (*pName)->GetSimpleName())->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
+
+        // we will not parse names that contain nulls
+        if (fParse && (wcslen(pString) != (size_t)iString))
+            ThrowHR(FUSION_E_INVALID_NAME);
+
         DWORD lgth = WszWideCharToMultiByte(CP_UTF8, 0, pString, iString, NULL, 0, NULL, NULL);
         if (lgth + 1 < lgth)
             ThrowHR(E_INVALIDARG);
@@ -290,7 +295,8 @@ HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF*
         SetName(lpName);
     }
 
-    if (fParse) {
+    if (fParse)
+    {
         HRESULT hr = ParseName();
         // Sometimes Fusion flags invalid characters in the name, sometimes it doesn't
         // depending on where the invalid characters are
diff --git a/src/coreclr/vm/assemblyspec.hpp b/src/coreclr/vm/assemblyspec.hpp
index 5d09b5b75a664e..d6ce12300170ed 100644
--- a/src/coreclr/vm/assemblyspec.hpp
+++ b/src/coreclr/vm/assemblyspec.hpp
@@ -105,7 +105,7 @@ class AssemblySpec  : public BaseAssemblySpec
     void InitializeSpec(PEAssembly* pPEAssembly);
     HRESULT InitializeSpec(StackingAllocator* alloc,
                         ASSEMBLYNAMEREF* pName,
-                        BOOL fParse = TRUE);
+                        BOOL fParse);
 
     void AssemblyNameInit(ASSEMBLYNAMEREF* pName, PEImage* pImageInfo); //[in,out], [in]
 
diff --git a/src/libraries/System.Reflection/tests/AssemblyNameTests.cs b/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
index 05f3bf31a0c685..7e9b8c5849b22d 100644
--- a/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
+++ b/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
@@ -68,6 +68,15 @@ public void Ctor_String(string name, string expectedName)
             Assert.Equal(ProcessorArchitecture.None, assemblyName.ProcessorArchitecture);
         }
 
+        [Theory]
+        [InlineData("MyAssemblyName, Version=1.0.0.0, PublicKeyToken=b77a5c561934e089", "MyAssemblyName, Version=1.0.0.0, PublicKeyToken=b77a5c561934e089")]
+        [InlineData("MyAssemblyName, Version=1.0.0.0, PublicKey=00000000000000000400000000000000", "MyAssemblyName, Version=1.0.0.0, PublicKeyToken=b77a5c561934e089")]
+        public void Ctor_String_Public_Key(string name, string expectedName)
+        {
+            AssemblyName assemblyName = new AssemblyName(name);
+            Assert.Equal(expectedName, assemblyName.FullName);
+        }
+
         [Theory]
         [InlineData(null, typeof(ArgumentNullException))]
         [InlineData("", typeof(ArgumentException))]
@@ -76,11 +85,40 @@ public void Ctor_String(string name, string expectedName)
         [InlineData("/a", typeof(FileLoadException))]
         [InlineData("           ", typeof(FileLoadException))]
         [InlineData("  \t \r \n ", typeof(FileLoadException))]
+        [InlineData("aa, culture=en-en, culture=en-en", typeof(FileLoadException))]
+        [InlineData("MyAssemblyName, PublicKey=00000000000000000400000000000000, PublicKeyToken=b77a5c561934e089", typeof(FileLoadException))]
         public void Ctor_String_Invalid(string assemblyName, Type exceptionType)
         {
             Assert.Throws(exceptionType, () => new AssemblyName(assemblyName));
         }
 
+        [Theory]
+        [InlineData("aaaa, language=en-en", "aaaa")]
+        [InlineData("aaaa, foo=bar, foo=baz", "aaaa")]
+        [InlineData("aaaa, foo = bar, foo = bar", "aaaa")]
+        [InlineData("aaaa, custom=10", "aaaa")]
+        [InlineData("aaaa, custom=10, custom=20", "aaaa")]
+        [InlineData("aaaa, custom=lalala", "aaaa")]
+        public void Ctor_String_Valid_Legacy(string name, string expectedName)
+        {
+            AssemblyName assemblyName = new AssemblyName(name);
+            Assert.Equal(expectedName, assemblyName.Name);
+        }
+
+        [Theory]
+        [InlineData("name\\u50; ", typeof(FileLoadException))]
+        [InlineData("aa/name ", typeof(FileLoadException))]
+        [InlineData("aa\\/tname", typeof(FileLoadException))]
+        [InlineData("aaaa, publickey=neutral", typeof(FileLoadException))]
+        [InlineData("aaaa, publickeytoken=neutral", typeof(FileLoadException))]
+        [InlineData("aaaa\0", typeof(FileLoadException))]
+        [InlineData("aaaa\0potato", typeof(FileLoadException))]
+        [InlineData("aaaa, publickeytoken=null\0,culture=en-en", typeof(FileLoadException))]
+        public void Ctor_String_Invalid_Legacy(string assemblyName, Type exceptionType)
+        {
+            Assert.Throws(exceptionType, () => new AssemblyName(assemblyName));
+        }
+
         [Theory]
         [InlineData("na,me", typeof(FileLoadException))]
         [InlineData("na=me", typeof(FileLoadException))]
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
index 867cf694cb2c4b..12b2a5936c3ded 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
@@ -19,6 +19,9 @@ public AssemblyName(string assemblyName)
             if (assemblyName.Length == 0 || assemblyName[0] == '\0')
                 throw new ArgumentException(SR.Format_StringZeroLength);
 
+            if (assemblyName.Contains('\0'))
+                throw new FileLoadException("The assembly name is invalid.");
+
             using (SafeStringMarshal name = RuntimeMarshal.MarshalString(assemblyName))
             {
                 // TODO: Should use CoreRT AssemblyNameParser
diff --git a/src/mono/mono/metadata/assembly.c b/src/mono/mono/metadata/assembly.c
index e8c4bbee3c0a46..493c3ff47d3c56 100644
--- a/src/mono/mono/metadata/assembly.c
+++ b/src/mono/mono/metadata/assembly.c
@@ -2544,7 +2544,7 @@ mono_assembly_name_parse_full (const char *name, MonoAssemblyName *aname, gboole
 	gchar *key_uq;
 	gchar *retargetable = NULL;
 	gchar *retargetable_uq;
-	gchar *procarch;
+	gchar *procarch = NULL;
 	gchar *procarch_uq;
 	gboolean res;
 	gchar *value, *part_name;
@@ -2590,43 +2590,47 @@ mono_assembly_name_parse_full (const char *name, MonoAssemblyName *aname, gboole
 
 		if (part_name_len == 7 && !g_ascii_strncasecmp (part_name, "Version", part_name_len)) {
 			*is_version_defined = TRUE;
-			version = value;
-			if (strlen (version) == 0) {
+			if (version != NULL || strlen (value) == 0) {
 				goto cleanup_and_fail;
 			}
+			version = value;
 			tmp++;
 			continue;
 		}
 
 		if (part_name_len == 7 && !g_ascii_strncasecmp (part_name, "Culture", part_name_len)) {
-			culture = value;
-			if (strlen (culture) == 0) {
+			if (culture != NULL || strlen (value) == 0) {
 				goto cleanup_and_fail;
 			}
+			culture = value;
 			tmp++;
 			continue;
 		}
 
 		if (part_name_len == 14 && !g_ascii_strncasecmp (part_name, "PublicKeyToken", part_name_len)) {
 			*is_token_defined = TRUE;
-			token = value;
-			if (strlen (token) == 0) {
+			if (token != NULL || key != NULL || strlen (value) == 0) {
 				goto cleanup_and_fail;
 			}
+			token = value;
 			tmp++;
 			continue;
 		}
 
 		if (part_name_len == 9 && !g_ascii_strncasecmp (part_name, "PublicKey", part_name_len)) {
-			key = value;
-			if (strlen (key) == 0) {
+			if (token != NULL || key != NULL || strlen (value) == 0) {
 				goto cleanup_and_fail;
 			}
+			key = value;
 			tmp++;
 			continue;
 		}
 
 		if (part_name_len == 12 && !g_ascii_strncasecmp (part_name, "Retargetable", part_name_len)) {
+			if (retargetable != NULL) {
+				goto cleanup_and_fail;
+			}
+
 			retargetable = value;
 			retargetable_uq = unquote (retargetable);
 			if (retargetable_uq != NULL)
@@ -2645,6 +2649,10 @@ mono_assembly_name_parse_full (const char *name, MonoAssemblyName *aname, gboole
 		}
 
 		if (part_name_len == 21 && !g_ascii_strncasecmp (part_name, "ProcessorArchitecture", part_name_len)) {
+			if (procarch != NULL) {
+				goto cleanup_and_fail;
+			}
+
 			procarch = value;
 			procarch_uq = unquote (procarch);
 			if (procarch_uq != NULL)
@@ -2672,7 +2680,8 @@ mono_assembly_name_parse_full (const char *name, MonoAssemblyName *aname, gboole
 			continue;
 		}
 
-		goto cleanup_and_fail;
+		// compat: If we got here, the attribute name is unknown to us. Ignore it.
+		tmp++;
 	}
 
 	/* if retargetable flag is set, then we must have a fully qualified name */

From 5605bdff4b104496941cc9e6acfc19783a52e7b8 Mon Sep 17 00:00:00 2001
From: Julius Hardt <julius@postfach-hardt.de>
Date: Sun, 23 Jan 2022 02:32:42 +0100
Subject: [PATCH 009/161] Dispose LdapConnections used by ValidateCredentials
 (#62036)

Ensure that cached LdapConnection instances created by
PrincipalContext.ValidateCredentials are disposed when
the corresponding PrincipalContext is disposed.

Fix #62035
---
 .../DirectoryServices/AccountManagement/Context.cs   | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/Context.cs b/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/Context.cs
index b132723c385ace..3a04bcc8a4b77c 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/Context.cs
+++ b/src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/Context.cs
@@ -44,7 +44,7 @@ internal static class CapabilityMap
         public const string LDAP_CAP_ACTIVE_DIRECTORY_V61_OID = "1.2.840.113556.1.4.1935";
     }
 
-    internal sealed class CredentialValidator
+    internal sealed class CredentialValidator : IDisposable
     {
         private enum AuthMethod
         {
@@ -341,6 +341,14 @@ public bool Validate(string userName, string password, ContextOptions connection
                 return (BindSam(_serverName, userName, password));
             }
         }
+
+        public void Dispose()
+        {
+            foreach (LdapConnection connection in _connCache.Values)
+            {
+                connection.Dispose();
+            }
+        }
     }
     // ********************************************
     public class PrincipalContext : IDisposable
@@ -1014,6 +1022,8 @@ public void Dispose()
                 if (_queryCtx != null)
                     _queryCtx.Dispose();
 
+                _credValidate.Dispose();
+
                 _disposed = true;
                 GC.SuppressFinalize(this);
             }

From 4a6d169f5391532340074b0be4cab737c6ccdfc8 Mon Sep 17 00:00:00 2001
From: Aaron Robinson <arobins@microsoft.com>
Date: Sun, 23 Jan 2022 09:39:24 -0500
Subject: [PATCH 010/161] Add runtime support for `ref` fields (#63985)

* Add mono and coreclr runtime support for ref fields

* Update Reflection.Emit tests to validate ref fields.

Add test for TypedReference as a ref field.
---
 .../System/Reflection/Emit/ModuleBuilder.cs   |  25 ++--
 .../src/System/Reflection/Emit/TypeBuilder.cs |   2 +
 src/coreclr/utilcode/util.cpp                 |   4 +-
 src/coreclr/vm/field.cpp                      |   8 +-
 src/coreclr/vm/jitinterface.cpp               |   3 -
 src/coreclr/vm/methodtablebuilder.cpp         |  26 +++-
 .../src/Resources/Strings.resx                |   3 -
 .../MethodBuilder/MethodBuilderByRefs.cs      |  21 +++
 .../ModuleBuilder/ModuleBuilderDefineEnum.cs  |   4 +-
 .../tests/System.Reflection.Emit.Tests.csproj |   1 +
 .../TypeBuilderAddInterfaceImplementaion.cs   |   7 -
 .../TypeBuilder/TypeBuilderDefineEvent.cs     |   6 +-
 .../TypeBuilder/TypeBuilderDefineField.cs     |  73 +++++++++--
 .../TypeBuilderDefineNestedType.cs            |   8 +-
 .../tests/TypeBuilder/TypeBuilderSetParent.cs |   4 +-
 .../System.Reflection.Emit/tests/Utilities.cs |  11 +-
 .../Reflection/Emit/ILGenerator.Mono.cs       |   3 -
 .../Reflection/Emit/TypeBuilder.Mono.cs       |  24 ++--
 src/mono/mono/metadata/class-init.c           |   8 ++
 src/mono/mono/metadata/class.c                |   9 +-
 src/mono/mono/metadata/object-internals.h     |   1 +
 src/mono/mono/metadata/object.c               |   1 +
 src/mono/mono/metadata/sre.c                  |  11 ++
 .../classloader/RefFields/InvalidCSharp.il    | 123 ++++++++++++++++++
 .../RefFields/InvalidCSharp.ilproj            |   8 ++
 .../Loader/classloader/RefFields/Validate.cs  |  59 +++++++++
 .../classloader/RefFields/Validate.csproj     |  12 ++
 src/tests/issues.targets                      |   5 +-
 28 files changed, 391 insertions(+), 79 deletions(-)
 create mode 100644 src/libraries/System.Reflection.Emit/tests/MethodBuilder/MethodBuilderByRefs.cs
 create mode 100644 src/tests/Loader/classloader/RefFields/InvalidCSharp.il
 create mode 100644 src/tests/Loader/classloader/RefFields/InvalidCSharp.ilproj
 create mode 100644 src/tests/Loader/classloader/RefFields/Validate.cs
 create mode 100644 src/tests/Loader/classloader/RefFields/Validate.csproj

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
index fe5da8367cdd43..f8b8c1efd35d03 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
@@ -233,7 +233,7 @@ private int GetTypeRefNested(Type type, Module? refedModule, string? strRefedMod
                 typeName = UnmangleTypeName(typeName);
             }
 
-            Debug.Assert(!type.IsByRef, "Must not be ByRef.");
+            Debug.Assert(!type.IsByRef, "Must not be ByRef. Get token from TypeSpec.");
             Debug.Assert(!type.IsGenericType || type.IsGenericTypeDefinition, "Must not have generic arguments.");
 
             ModuleBuilder thisModule = this;
@@ -1081,19 +1081,16 @@ private int GetTypeTokenWorkerNoLock(Type type, bool getGenericDefinition)
             // instructions.  Tokens are always relative to the Module.  For example,
             // the token value for System.String is likely to be different from
             // Module to Module.  Calling GetTypeToken will cause a reference to be
-            // added to the Module.  This reference becomes a perminate part of the Module,
-            // multiple calles to this method with the same class have no additional side affects.
-            // This function is optimized to use the TypeDef token if Type is within the same module.
-            // We should also be aware of multiple dynamic modules and multiple implementation of Type!!!
-            if (type.IsByRef)
-            {
-                throw new ArgumentException(SR.Argument_CannotGetTypeTokenForByRef);
-            }
-
-            if ((type.IsGenericType && (!type.IsGenericTypeDefinition || !getGenericDefinition)) ||
-                type.IsGenericParameter ||
-                type.IsArray ||
-                type.IsPointer)
+            // added to the Module.  This reference becomes a permanent part of the Module,
+            // multiple calls to this method with the same class have no additional side-effects.
+            // This function is optimized to use the TypeDef token if the Type is within the
+            // same module. We should also be aware of multiple dynamic modules and multiple
+            // implementations of a Type.
+            if ((type.IsGenericType && (!type.IsGenericTypeDefinition || !getGenericDefinition))
+                || type.IsGenericParameter
+                || type.IsArray
+                || type.IsPointer
+                || type.IsByRef)
             {
                 byte[] sig = SignatureHelper.GetTypeSigToken(this, type).InternalGetSignature(out int length);
                 return GetTokenFromTypeSpec(sig, length);
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
index 6d9b8121fa6b42..a242ec948896be 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
@@ -1922,7 +1922,9 @@ private EventBuilder DefineEventNoLock(string name, EventAttributes attributes,
 
             int tkParent = 0;
             if (m_typeParent != null)
+            {
                 tkParent = m_module.GetTypeTokenInternal(m_typeParent);
+            }
 
             ModuleBuilder module = m_module;
 
diff --git a/src/coreclr/utilcode/util.cpp b/src/coreclr/utilcode/util.cpp
index 44b5250547689c..bf31761902dcef 100644
--- a/src/coreclr/utilcode/util.cpp
+++ b/src/coreclr/utilcode/util.cpp
@@ -1806,9 +1806,7 @@ HRESULT validateOneArg(
                 // Validate the referenced type.
                 if(FAILED(hr = validateOneArg(tk, pSig, pulNSentinels, pImport, FALSE))) IfFailGo(hr);
                 break;
-            case ELEMENT_TYPE_BYREF:  //fallthru
-                if(TypeFromToken(tk)==mdtFieldDef) IfFailGo(VLDTR_E_SIG_BYREFINFIELD);
-                FALLTHROUGH;
+            case ELEMENT_TYPE_BYREF:
             case ELEMENT_TYPE_PINNED:
             case ELEMENT_TYPE_SZARRAY:
                 // Validate the referenced type.
diff --git a/src/coreclr/vm/field.cpp b/src/coreclr/vm/field.cpp
index a0e1260976dee8..3855f4a22c0df7 100644
--- a/src/coreclr/vm/field.cpp
+++ b/src/coreclr/vm/field.cpp
@@ -61,6 +61,8 @@ VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttr
         FieldType == ELEMENT_TYPE_R8 ||
         FieldType == ELEMENT_TYPE_CLASS ||
         FieldType == ELEMENT_TYPE_VALUETYPE ||
+        FieldType == ELEMENT_TYPE_BYREF ||
+        FieldType == ELEMENT_TYPE_TYPEDBYREF ||
         FieldType == ELEMENT_TYPE_PTR ||
         FieldType == ELEMENT_TYPE_FNPTR
         );
@@ -70,7 +72,8 @@ VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttr
     m_requiresFullMbValue = 0;
     SetMemberDef(mb);
 
-    m_type = FieldType;
+    // A TypedByRef should be treated like a regular value type.
+    m_type = FieldType != ELEMENT_TYPE_TYPEDBYREF ? FieldType : ELEMENT_TYPE_VALUETYPE;
     m_prot = fdFieldAccessMask & dwMemberAttrs;
     m_isStatic = fIsStatic != 0;
     m_isRVA = fIsRVA != 0;
@@ -81,7 +84,7 @@ VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttr
 #endif
 
     _ASSERTE(GetMemberDef() == mb);                 // no truncation
-    _ASSERTE(GetFieldType() == FieldType);
+    _ASSERTE(GetFieldType() == FieldType || (FieldType == ELEMENT_TYPE_TYPEDBYREF && m_type == ELEMENT_TYPE_VALUETYPE));
     _ASSERTE(GetFieldProtection() == (fdFieldAccessMask & dwMemberAttrs));
     _ASSERTE((BOOL) IsStatic() == (fIsStatic != 0));
 }
@@ -152,6 +155,7 @@ TypeHandle FieldDesc::LookupFieldTypeHandle(ClassLoadLevel level, BOOL dropGener
     _ASSERTE(type == ELEMENT_TYPE_CLASS ||
              type == ELEMENT_TYPE_VALUETYPE ||
              type == ELEMENT_TYPE_STRING ||
+             type == ELEMENT_TYPE_TYPEDBYREF ||
              type == ELEMENT_TYPE_SZARRAY ||
              type == ELEMENT_TYPE_VAR
              );
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
index e28434acabe56e..f02693ae034219 100644
--- a/src/coreclr/vm/jitinterface.cpp
+++ b/src/coreclr/vm/jitinterface.cpp
@@ -9002,9 +9002,6 @@ CorInfoType CEEInfo::getFieldTypeInternal (CORINFO_FIELD_HANDLE fieldHnd,
     FieldDesc* field = (FieldDesc*) fieldHnd;
     CorElementType type   = field->GetFieldType();
 
-    // <REVISIT_TODO>TODO should not burn the time to do this for anything but Value Classes</REVISIT_TODO>
-    _ASSERTE(type != ELEMENT_TYPE_BYREF);
-
     if (type == ELEMENT_TYPE_I)
     {
         PTR_MethodTable enclosingMethodTable = field->GetApproxEnclosingMethodTable();
diff --git a/src/coreclr/vm/methodtablebuilder.cpp b/src/coreclr/vm/methodtablebuilder.cpp
index 68d11affa4351f..59566e2e717179 100644
--- a/src/coreclr/vm/methodtablebuilder.cpp
+++ b/src/coreclr/vm/methodtablebuilder.cpp
@@ -3935,6 +3935,27 @@ VOID    MethodTableBuilder::InitializeFieldDescs(FieldDesc *pFieldDescList,
                 break;
             }
 
+        case ELEMENT_TYPE_BYREF:
+            {
+                dwLog2FieldSize = LOG2_PTRSIZE;
+                if (fIsStatic)
+                {
+                    // Byref-like types cannot be used for static fields
+                    BuildMethodTableThrowException(IDS_CLASSLOAD_BYREFLIKE_STATICFIELD);
+                }
+                if (!bmtFP->fIsByRefLikeType)
+                {
+                    // Non-byref-like types cannot contain byref-like instance fields
+                    BuildMethodTableThrowException(IDS_CLASSLOAD_BYREFLIKE_INSTANCEFIELD);
+                }
+                break;
+            }
+
+        case ELEMENT_TYPE_TYPEDBYREF:
+            {
+                goto IS_VALUETYPE;
+            }
+
         // Class type variable (method type variables aren't allowed in fields)
         // These only occur in open types used for verification/reflection.
         case ELEMENT_TYPE_VAR:
@@ -4042,7 +4063,10 @@ VOID    MethodTableBuilder::InitializeFieldDescs(FieldDesc *pFieldDescList,
                         pByValueClass = (MethodTable *)-1;
                     }
                 } // If 'this' is a value class
-
+            }
+            // TypedReference shares the rest of the code here
+IS_VALUETYPE:
+            {
                 // It's not self-referential so try to load it
                 if (pByValueClass == NULL)
                 {
diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
index f98789424343b4..e9d5e447ee90fc 100644
--- a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -903,9 +903,6 @@
   <data name="Argument_CannotCreateTypedReference" xml:space="preserve">
     <value>Cannot use function evaluation to create a TypedReference object.</value>
   </data>
-  <data name="Argument_CannotGetTypeTokenForByRef" xml:space="preserve">
-    <value>Cannot get TypeToken for a ByRef type.</value>
-  </data>
   <data name="Argument_CannotSetParentToInterface" xml:space="preserve">
     <value>Cannot set parent to an interface.</value>
   </data>
diff --git a/src/libraries/System.Reflection.Emit/tests/MethodBuilder/MethodBuilderByRefs.cs b/src/libraries/System.Reflection.Emit/tests/MethodBuilder/MethodBuilderByRefs.cs
new file mode 100644
index 00000000000000..01baa3bc010d94
--- /dev/null
+++ b/src/libraries/System.Reflection.Emit/tests/MethodBuilder/MethodBuilderByRefs.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Linq;
+using Xunit;
+
+namespace System.Reflection.Emit.Tests
+{
+    public class MethodBuilderByRefs
+    {
+        [Fact]
+        public void ByRef_Ldtoken()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+            MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public, typeof(Type), Type.EmptyTypes);
+            ILGenerator ilg = method.GetILGenerator();
+            ilg.Emit(OpCodes.Ldtoken, typeof(int).MakeByRefType());
+            ilg.Emit(OpCodes.Ret);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineEnum.cs b/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineEnum.cs
index 34433ae11f3918..e1d927cfa25b02 100644
--- a/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineEnum.cs
+++ b/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineEnum.cs
@@ -160,11 +160,11 @@ public void DefineEnum_VoidUnderlyingType_ThrowsArgumentException()
         }
 
         [Fact]
-        public void DefineEnum_ByRefUnderlyingType_ThrowsCOMExceptionOnCreation()
+        public void DefineEnum_ByRefUnderlyingType_ThrowsTypeLoadExceptionOnCreation()
         {
             ModuleBuilder module = Helpers.DynamicModule();
             EnumBuilder enumBuilder = module.DefineEnum("Name", TypeAttributes.Public, typeof(int).MakeByRefType());
-            Assert.Throws<COMException>(() => enumBuilder.CreateTypeInfo());
+            Assert.Throws<TypeLoadException>(() => enumBuilder.CreateTypeInfo());
         }
 
         [Theory]
diff --git a/src/libraries/System.Reflection.Emit/tests/System.Reflection.Emit.Tests.csproj b/src/libraries/System.Reflection.Emit/tests/System.Reflection.Emit.Tests.csproj
index e5d46e991da82f..d47bdd3466c796 100644
--- a/src/libraries/System.Reflection.Emit/tests/System.Reflection.Emit.Tests.csproj
+++ b/src/libraries/System.Reflection.Emit/tests/System.Reflection.Emit.Tests.csproj
@@ -33,6 +33,7 @@
     <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetCustomAttribute.cs" />
     <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetGenericParameterAttributes.cs" />
     <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetInterfaceConstraints.cs" />
+    <Compile Include="MethodBuilder\MethodBuilderByRefs.cs" />
     <Compile Include="MethodBuilder\MethodBuilderContainsGenericParameters.cs" />
     <Compile Include="MethodBuilder\MethodBuilderDefineGenericParameters.cs" />
     <Compile Include="MethodBuilder\MethodBuilderDefineParameter.cs" />
diff --git a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderAddInterfaceImplementaion.cs b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderAddInterfaceImplementaion.cs
index 8d9adab4662e03..da3e695dcd389c 100644
--- a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderAddInterfaceImplementaion.cs
+++ b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderAddInterfaceImplementaion.cs
@@ -61,13 +61,6 @@ public void AddInterfaceImplementation_NullInterfaceType_ThrowsArgumentNullExcep
             AssertExtensions.Throws<ArgumentNullException>("interfaceType", () => type.AddInterfaceImplementation(null));
         }
 
-        [Fact]
-        public void AddInterfaceImplementation_ByRefInterfaceType_ThrowsArgumentExceptioN()
-        {
-            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
-            AssertExtensions.Throws<ArgumentException>(null, () => type.AddInterfaceImplementation(typeof(int).MakeByRefType()));
-        }
-
         [Fact]
         public void AddInterfaceImplementation_TypeAlreadyCreated_ThrowsInvalidOperationException()
         {
diff --git a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineEvent.cs b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineEvent.cs
index 2c7452339c9e84..59ebb7fc77bb40 100644
--- a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineEvent.cs
+++ b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineEvent.cs
@@ -106,11 +106,11 @@ public void DefineEvent_Invalid(string name, Type eventType, Type exceptionType)
         }
 
         [Fact]
-        public void DefineEvent_ByRefEventType_ThrowsArgumentException()
+        public void DefineEvent_ByRefEventType()
         {
             TypeBuilder type = Helpers.DynamicType(TypeAttributes.Class | TypeAttributes.Public);
-
-            AssertExtensions.Throws<ArgumentException>(null, () => type.DefineEvent("Name", EventAttributes.None, typeof(int).MakeByRefType()));
+            type.DefineEvent("Name", EventAttributes.None, typeof(int).MakeByRefType());
+            type.CreateTypeInfo().AsType();
         }
 
         [Fact]
diff --git a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineField.cs b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineField.cs
index e765a08dcc403d..a09e69f6738adf 100644
--- a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineField.cs
+++ b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineField.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Xunit;
 
@@ -112,15 +113,6 @@ public void DefineField_VoidFieldType_ThrowsArgumentException()
             AssertExtensions.Throws<ArgumentException>(null, () => type.DefineField("Name", typeof(void), FieldAttributes.Public));
         }
 
-        [Fact]
-        public void DefineField_ByRefFieldType_ThrowsCOMExceptionOnCreation()
-        {
-            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
-            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
-
-            Assert.Throws<COMException>(() => type.CreateTypeInfo());
-        }
-
         [Theory]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/2389", TestRuntimes.Mono)]
         [InlineData((FieldAttributes)(-1), (FieldAttributes)(-38145))]
@@ -152,6 +144,69 @@ public void DefineField_DynamicFieldTypeNotCreated_ThrowsTypeLoadException()
             Assert.Equal(createdFieldType, field.FieldType);
         }
 
+        [Fact]
+        public void DefineByRefField_Class_ThrowsTypeLoadExceptionOnCreation()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
+
+            Assert.Throws<TypeLoadException>(() => type.CreateTypeInfo());
+        }
+
+        [Fact]
+        public void DefineByRefField_ValueType_NonByRefLike_ThrowsTypeLoadExceptionOnCreation()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public, baseType: typeof(ValueType));
+            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
+
+            Assert.Throws<TypeLoadException>(() => type.CreateTypeInfo());
+        }
+
+        [Fact]
+        public void DefineByRefField_ValueType_ByRefLike()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public, baseType: typeof(ValueType));
+
+            // Define type to be ByRefLike
+            CustomAttributeBuilder ca = new(typeof(IsByRefLikeAttribute).GetConstructors()[0], new object[] { });
+            type.SetCustomAttribute(ca);
+
+            type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
+
+            Type createdType = type.CreateTypeInfo().AsType();
+            FieldInfo[] fields = createdType.GetFields();
+            Assert.Equal(1, fields.Length);
+            Assert.True(fields[0].FieldType.IsByRef);
+        }
+
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/45152")]
+        public void Instantiate_ValueType_With_ByRefField()
+        {
+            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public, baseType: typeof(ValueType));
+
+            // Define type to be ByRefLike
+            CustomAttributeBuilder ca = new(typeof(IsByRefLikeAttribute).GetConstructors()[0], new object[] { });
+            type.SetCustomAttribute(ca);
+
+            var field = type.DefineField("Name", typeof(int).MakeByRefType(), FieldAttributes.Public);
+
+            var ctor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[] { typeof(string) });
+            {
+                ILGenerator il = ctor.GetILGenerator();
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(OpCodes.Ldarga_S, 1);
+                il.Emit(OpCodes.Stfld, field);
+                il.Emit(OpCodes.Ret);
+            }
+
+            Type createdType = type.CreateTypeInfo().AsType();
+
+            var ctorToCall = createdType.GetConstructor(BindingFlags.Public | BindingFlags.Instance, new[] { typeof(string) });
+            var str = "12345";
+            ctorToCall.Invoke(new[] { str });
+        }
+
         [Fact]
         public void GetField_TypeNotCreated_ThrowsNotSupportedException()
         {
diff --git a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineNestedType.cs b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineNestedType.cs
index cf24e8d87adad7..d71506544525d6 100644
--- a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineNestedType.cs
+++ b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderDefineNestedType.cs
@@ -210,15 +210,9 @@ public void DefineNestedType_NullInterface_ThrowsArgumentNullException()
             AssertExtensions.Throws<ArgumentNullException>("interfaces", () => type.DefineNestedType("Name", TypeAttributes.NestedPublic, typeof(object), new Type[] { null }));
         }
 
-        [Fact]
-        public void DefineNestedType_ByRefInterfaceType_ThrowsArgumentException()
-        {
-            TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
-            AssertExtensions.Throws<ArgumentException>(null, () => type.DefineNestedType("Name", TypeAttributes.NestedPublic, typeof(object), new Type[] { typeof(int).MakeByRefType() }));
-        }
-
         public static IEnumerable<object[]> InvalidInterfaceType_TestData()
         {
+            yield return new object[] { typeof(int).MakeByRefType() };
             yield return new object[] { typeof(EmptyNonGenericClass) };
             yield return new object[] { typeof(EmptyNonGenericStruct) };
             yield return new object[] { typeof(EmptyGenericClass<int>) };
diff --git a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderSetParent.cs b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderSetParent.cs
index 8a4e5ace9ec8d7..5c985d52a46769 100644
--- a/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderSetParent.cs
+++ b/src/libraries/System.Reflection.Emit/tests/TypeBuilder/TypeBuilderSetParent.cs
@@ -56,14 +56,14 @@ public void SetParent_InterfaceType_ThrowsArgumentException(TypeAttributes attri
         }
 
         [Fact]
-        public void SetParent_ByRefType_ThrowsArgumentExceptionOnCreation()
+        public void SetParent_ByRefType_ThrowsNotSupportedExceptionOnCreation()
         {
             TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
 
             type.SetParent(typeof(int).MakeByRefType());
             Assert.Equal(typeof(int).MakeByRefType(), type.BaseType);
 
-            AssertExtensions.Throws<ArgumentException>(null, () => type.CreateTypeInfo());
+            Assert.Throws<NotSupportedException>(() => type.CreateTypeInfo());
         }
 
         [Fact]
diff --git a/src/libraries/System.Reflection.Emit/tests/Utilities.cs b/src/libraries/System.Reflection.Emit/tests/Utilities.cs
index 8e1c965e19a274..1e951be849a862 100644
--- a/src/libraries/System.Reflection.Emit/tests/Utilities.cs
+++ b/src/libraries/System.Reflection.Emit/tests/Utilities.cs
@@ -54,9 +54,16 @@ public static ModuleBuilder DynamicModule(string assemblyName = "TestAssembly",
             return DynamicAssembly(assemblyName).DefineDynamicModule(moduleName);
         }
 
-        public static TypeBuilder DynamicType(TypeAttributes attributes, string assemblyName = "TestAssembly", string moduleName = "TestModule", string typeName = "TestType")
+        public static TypeBuilder DynamicType(TypeAttributes attributes, string assemblyName = "TestAssembly", string moduleName = "TestModule", string typeName = "TestType", Type? baseType = null)
         {
-            return DynamicModule(assemblyName, moduleName).DefineType(typeName, attributes);
+            if (baseType is null)
+            {
+                return DynamicModule(assemblyName, moduleName).DefineType(typeName, attributes);
+            }
+            else
+            {
+                return DynamicModule(assemblyName, moduleName).DefineType(typeName, attributes, baseType);
+            }
         }
 
         public static EnumBuilder DynamicEnum(TypeAttributes visibility, Type underlyingType, string enumName = "TestEnum", string assemblyName = "TestAssembly", string moduleName = "TestModule")
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.Mono.cs
index 51edf3f6448752..64585857fffc09 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.Mono.cs
@@ -819,9 +819,6 @@ public virtual void Emit(OpCode opcode, string str)
 
         public virtual void Emit(OpCode opcode, Type cls)
         {
-            if (cls != null && cls.IsByRef)
-                throw new ArgumentException("Cannot get TypeToken for a ByRef type.");
-
             make_room(6);
             ll_emit(opcode);
             int token = token_gen.GetToken(cls!, opcode != OpCodes.Ldtoken);
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
index 1e73f98f1505f8..1209f517736a40 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
@@ -74,6 +74,7 @@ public sealed partial class TypeBuilder : TypeInfo
 
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
         private TypeInfo? created;
+        private bool is_byreflike_set;
 
         private int state;
 #endregion
@@ -273,8 +274,7 @@ public void AddInterfaceImplementation([DynamicallyAccessedMembers(DynamicallyAc
         {
             if (interfaceType == null)
                 throw new ArgumentNullException(nameof(interfaceType));
-            if (interfaceType.IsByRef)
-                throw new ArgumentException(SR.Argument_CannotGetTypeTokenForByRef);
+
             check_not_created();
 
             if (interfaces != null)
@@ -838,7 +838,7 @@ private bool has_ctor_method()
             if (parent != null)
             {
                 if (parent.IsByRef)
-                    throw new ArgumentException();
+                    throw new NotSupportedException();
                 if (IsInterface)
                     throw new TypeLoadException();
             }
@@ -877,17 +877,6 @@ private bool has_ctor_method()
                 }
             }
 
-            if (fields != null)
-            {
-                foreach (FieldBuilder fb in fields)
-                {
-                    if (fb == null)
-                        continue;
-                    if (fb.FieldType.IsByRef)
-                        throw new COMException();
-                }
-            }
-
             if (methods != null)
             {
                 bool is_concrete = !IsAbstract;
@@ -1544,6 +1533,10 @@ public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
             {
                 attrs |= TypeAttributes.HasSecurity;
             }
+            else if (attrname == "System.Runtime.CompilerServices.IsByRefLikeAttribute")
+            {
+                is_byreflike_set = true;
+            }
 
             if (cattrs != null)
             {
@@ -1571,8 +1564,7 @@ public EventBuilder DefineEvent(string name, EventAttributes attributes, Type ev
             if (eventtype == null)
                 throw new ArgumentNullException(nameof(eventtype));
             check_not_created();
-            if (eventtype.IsByRef)
-                throw new ArgumentException(SR.Argument_CannotGetTypeTokenForByRef);
+
             EventBuilder res = new EventBuilder(this, name, attributes, eventtype);
             if (events != null)
             {
diff --git a/src/mono/mono/metadata/class-init.c b/src/mono/mono/metadata/class-init.c
index 2ae4f39dab8554..0d8a74442b4d26 100644
--- a/src/mono/mono/metadata/class-init.c
+++ b/src/mono/mono/metadata/class-init.c
@@ -364,6 +364,14 @@ mono_class_setup_fields (MonoClass *klass)
 			g_free (type_name);
 			break;
 		}
+		if (m_type_is_byref (field->type)) {
+			if (!m_class_is_byreflike (klass)) {
+				char *class_name = mono_type_get_full_name (klass);
+				mono_class_set_type_load_failure (klass, "Type %s is not a ByRefLike type so ref field, '%s', is invalid", class_name, field->name);
+				g_free (class_name);
+				break;
+			}
+		}
 		/* The def_value of fields is compute lazily during vtable creation */
 	}
 
diff --git a/src/mono/mono/metadata/class.c b/src/mono/mono/metadata/class.c
index 895a654cbfeaad..eceb20cf4d0f63 100644
--- a/src/mono/mono/metadata/class.c
+++ b/src/mono/mono/metadata/class.c
@@ -4626,13 +4626,20 @@ mono_ldtoken_checked (MonoImage *image, guint32 token, MonoClass **handle_class,
 	case MONO_TOKEN_TYPE_REF:
 	case MONO_TOKEN_TYPE_SPEC: {
 		MonoType *type;
+		MonoClass *klass;
 		if (handle_class)
 			*handle_class = mono_defaults.typehandle_class;
 		type = mono_type_get_checked (image, token, context, error);
 		if (!type)
 			return NULL;
 
-		mono_class_init_internal (mono_class_from_mono_type_internal (type));
+		klass = mono_class_from_mono_type_internal (type);
+		mono_class_init_internal (klass);
+		if (mono_class_has_failure (klass)) {
+			mono_error_set_for_class_failure (error, klass);
+			return NULL;
+		}
+
 		/* We return a MonoType* as handle */
 		return type;
 	}
diff --git a/src/mono/mono/metadata/object-internals.h b/src/mono/mono/metadata/object-internals.h
index 2be830e375b151..efa4b0624548d6 100644
--- a/src/mono/mono/metadata/object-internals.h
+++ b/src/mono/mono/metadata/object-internals.h
@@ -1222,6 +1222,7 @@ struct _MonoReflectionTypeBuilder {
 	MonoGenericContainer *generic_container;
 	MonoArray *generic_params;
 	MonoReflectionType *created;
+	gboolean is_byreflike_set;
 	gint32 state;
 };
 
diff --git a/src/mono/mono/metadata/object.c b/src/mono/mono/metadata/object.c
index d87fade6e61228..5863a967d544f0 100644
--- a/src/mono/mono/metadata/object.c
+++ b/src/mono/mono/metadata/object.c
@@ -887,6 +887,7 @@ compute_class_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset, int
 				} else {
 					/* fall through */
 				}
+			case MONO_TYPE_TYPEDBYREF:
 			case MONO_TYPE_VALUETYPE: {
 				MonoClass *fclass = mono_class_from_mono_type_internal (field->type);
 				if (m_class_has_references (fclass)) {
diff --git a/src/mono/mono/metadata/sre.c b/src/mono/mono/metadata/sre.c
index 5a9e16eb81b8f1..62254b3fa2c3e8 100644
--- a/src/mono/mono/metadata/sre.c
+++ b/src/mono/mono/metadata/sre.c
@@ -3556,6 +3556,11 @@ typebuilder_setup_one_field (MonoDynamicImage *dynamic_image, MonoClass *klass,
 			}
 		}
 
+		if (m_type_is_byref (field->type) && !m_class_is_byreflike (klass)) {
+			mono_error_set_type_load_name (error, NULL, NULL, "Field '%s' is a byref in a non-byref-like type", field->name);
+			goto leave;
+		}
+
 		if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && (rva_data = fb->rva_data)) {
 			char *base = mono_array_addr_internal (rva_data, char, 0);
 			size_t size = mono_array_length_internal (rva_data);
@@ -3857,6 +3862,12 @@ ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilderHandle ref_
 	mono_class_setup_supertypes (klass);
 	mono_class_setup_mono_type (klass);
 
+	/* Check if the type is marked as byreflike.
+	 * The IsByRefLike attribute only applies to value types and enums. This matches CoreCLR behavior.
+	 */
+	if (klass->enumtype || klass->valuetype)
+		klass->is_byreflike = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionTypeBuilder, ref_tb), is_byreflike_set);
+
 	/* enums are done right away */
 	if (!klass->enumtype)
 		if (!ensure_runtime_vtable (klass, error))
diff --git a/src/tests/Loader/classloader/RefFields/InvalidCSharp.il b/src/tests/Loader/classloader/RefFields/InvalidCSharp.il
new file mode 100644
index 00000000000000..b976227547def5
--- /dev/null
+++ b/src/tests/Loader/classloader/RefFields/InvalidCSharp.il
@@ -0,0 +1,123 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+.assembly extern System.Runtime { .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) }
+
+.assembly InvalidCSharp { }
+
+.class public auto ansi sealed beforefieldinit InvalidCSharp.InvalidStructWithRefField
+    extends [System.Runtime]System.ValueType
+{
+    // Type requires IsByRefLikeAttribute to be valid.
+    .field public string& invalid
+}
+
+// This is invalid metadata and is unable to be loaded.
+// -  [field sig] (0x80131815 (VER_E_FIELD_SIG))
+//
+// .class public auto ansi sealed beforefieldinit InvalidCSharp.InvalidStructWithStaticRefField
+//     extends [System.Runtime]System.ValueType
+// {
+//     .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = (
+//         01 00 00 00
+//     )
+//     .field public static string& invalid
+// }
+
+.class public auto ansi sealed beforefieldinit InvalidCSharp.WithRefField
+    extends [System.Runtime]System.ValueType
+{
+    .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = (
+        01 00 00 00
+    )
+    .field public string& Str
+
+    .method public hidebysig specialname rtspecialname
+        instance void .ctor (
+            string&
+        ) cil managed
+    {
+        ldarg.0
+        ldarg.1
+        stfld string& InvalidCSharp.WithRefField::Str
+        ret
+    }
+
+    .method public hidebysig
+        instance bool ConfirmFieldInstance (
+            string
+        ) cil managed
+    {
+        ldarg.0
+        ldfld string& InvalidCSharp.WithRefField::Str
+        ldind.ref
+        ldarg.1
+        ceq
+        ret
+    }
+}
+
+.class public auto ansi sealed beforefieldinit InvalidCSharp.WithRefStructField
+    extends [System.Runtime]System.ValueType
+{
+    .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = (
+        01 00 00 00
+    )
+    .field public valuetype InvalidCSharp.WithRefField& Field
+
+    .method public hidebysig specialname rtspecialname
+        instance void .ctor (
+            valuetype InvalidCSharp.WithRefField&
+        ) cil managed
+    {
+        ldarg.0
+        ldarg.1
+        stfld valuetype InvalidCSharp.WithRefField& InvalidCSharp.WithRefStructField::Field
+        ret
+    }
+
+    .method public hidebysig
+        instance bool ConfirmFieldInstance (
+            valuetype InvalidCSharp.WithRefField&
+        ) cil managed
+    {
+        ldarg.0
+        ldfld valuetype InvalidCSharp.WithRefField& InvalidCSharp.WithRefStructField::Field
+        ldind.ref
+        ldarg.1
+        ldind.ref
+        ceq
+        ret
+    }
+}
+
+.class public auto ansi sealed beforefieldinit InvalidCSharp.WithTypedReferenceField`1<T>
+    extends [System.Runtime]System.ValueType
+{
+    .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = (
+        01 00 00 00
+    )
+    .field public typedref Field
+
+    .method public hidebysig specialname rtspecialname
+        instance void .ctor (
+            !T
+        ) cil managed
+    {
+        ldarg.0
+        ldarga.s 1
+        mkrefany !T
+        stfld typedref InvalidCSharp.WithTypedReferenceField`1::Field
+        ret
+    }
+
+    .method public hidebysig
+        instance class [System.Runtime]System.Type GetFieldType () cil managed
+    {
+        ldarg.0
+        ldfld typedref InvalidCSharp.WithTypedReferenceField`1::Field
+        refanytype
+        call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle )
+        ret
+    }
+}
\ No newline at end of file
diff --git a/src/tests/Loader/classloader/RefFields/InvalidCSharp.ilproj b/src/tests/Loader/classloader/RefFields/InvalidCSharp.ilproj
new file mode 100644
index 00000000000000..d577c8f9c7a1a1
--- /dev/null
+++ b/src/tests/Loader/classloader/RefFields/InvalidCSharp.ilproj
@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk.IL">
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="InvalidCSharp.il" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/Loader/classloader/RefFields/Validate.cs b/src/tests/Loader/classloader/RefFields/Validate.cs
new file mode 100644
index 00000000000000..bffcd53de2f00a
--- /dev/null
+++ b/src/tests/Loader/classloader/RefFields/Validate.cs
@@ -0,0 +1,59 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.IO;
+using InvalidCSharp;
+
+using Xunit;
+
+class Validate
+{
+    [Fact]
+    public static void Validate_Invalid_RefField_Fails()
+    {
+        Console.WriteLine($"{nameof(Validate_Invalid_RefField_Fails)}...");
+        Assert.Throws<TypeLoadException>(() => { var t = typeof(InvalidStructWithRefField); });
+    }
+
+    [Fact]
+    public static void Validate_RefStructWithRefField_Load()
+    {
+        Console.WriteLine($"{nameof(Validate_RefStructWithRefField_Load)}...");
+        var t = typeof(WithRefField);
+    }
+
+    [Fact]
+    public static void Validate_Create_RefField()
+    {
+        var str = nameof(Validate_Create_RefField);
+        Console.WriteLine($"{str}...");
+
+        WithRefField s = new(ref str);
+        Assert.True(s.ConfirmFieldInstance(str));
+
+        string newStr = new(str);
+        Assert.False(s.ConfirmFieldInstance(newStr));
+    }
+
+    [Fact]
+    public static void Validate_Create_RefStructField()
+    {
+        var str = nameof(Validate_Create_RefStructField);
+        Console.WriteLine($"{str}...");
+
+        WithRefField s = new(ref str);
+        WithRefStructField t = new(ref s);
+        Assert.True(t.ConfirmFieldInstance(ref s));
+    }
+
+    [Fact]
+    public static void Validate_Create_TypedReferenceRefField()
+    {
+        Console.WriteLine($"{nameof(Validate_Create_TypedReferenceRefField)}...");
+
+        Validate v = new();
+        WithTypedReferenceField<Validate> s = new(v);
+        Assert.Equal(typeof(Validate), s.GetFieldType());
+    }
+}
\ No newline at end of file
diff --git a/src/tests/Loader/classloader/RefFields/Validate.csproj b/src/tests/Loader/classloader/RefFields/Validate.csproj
new file mode 100644
index 00000000000000..96fedddd4bdda7
--- /dev/null
+++ b/src/tests/Loader/classloader/RefFields/Validate.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Validate.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="InvalidCSharp.ilproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index 7b718aa15617d3..edf95e8c106f62 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -1329,7 +1329,7 @@
         <!-- Static virtual methods -->
         <ExcludeList Include="$(XunitTestBinBase)/Loader\classloader\StaticVirtualMethods\**" />
     </ItemGroup>
-  
+
     <!-- run.proj finds all the *.cmd/*.sh scripts in a test folder and creates corresponding test methods.
          Exclude these scripts to avoid creating such methods for the superpmicollect dependent test projects
          and running them separately from superpmicollect test. These should be excluded regardless of RuntimeFlavor/os/arch-->
@@ -2589,6 +2589,9 @@
         <ExcludeList Include = "$(XunitTestBinBase)/Loader/classloader/explicitlayout/NestedStructs/case05/**">
             <Issue>expected failure: overlapped structs fail at AOT compile time, not runtime</Issue>
         </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/Loader/classloader/RefFields/Validate/**">
+            <Issue>expected failure: unsupported type with ref field fails at AOT compile time, not runtime</Issue>
+        </ExcludeList>
         <ExcludeList Include = "$(XunitTestBinBase)/Interop/SuppressGCTransition/SuppressGCTransitionTest/**">
             <Issue>https://github.com/dotnet/runtime/issues/57361</Issue>
         </ExcludeList>

From 605ed5d89dc8e3dde2c9d4ca8072f9bd41d54333 Mon Sep 17 00:00:00 2001
From: Egor Chesakov <Egor.Chesakov@microsoft.com>
Date: Sun, 23 Jan 2022 14:07:40 -0800
Subject: [PATCH 011/161] Spmi replay asmdiffs mac os arm64 (#64119)

* Split unix-arm64 into linux-arm64 and osx-arm64 in src/coreclr/scripts/superpmi-replay.proj

* Split unix-arm64 into linux-arm64 and osx-arm64 in src/coreclr/scripts/superpmi-asmdiffs.proj

* Add all subdirectories of $(SuperPMIDirectory) as PMIPATH in src/coreclr/scripts/superpmi-collect.proj
---
 src/coreclr/scripts/superpmi-asmdiffs.proj | 3 ++-
 src/coreclr/scripts/superpmi-collect.proj  | 9 +++++++--
 src/coreclr/scripts/superpmi-replay.proj   | 3 ++-
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/coreclr/scripts/superpmi-asmdiffs.proj b/src/coreclr/scripts/superpmi-asmdiffs.proj
index aef782d769cb9e..661a60aca831a2 100644
--- a/src/coreclr/scripts/superpmi-asmdiffs.proj
+++ b/src/coreclr/scripts/superpmi-asmdiffs.proj
@@ -55,7 +55,8 @@
     <SPMI_Partition Include="win-x64" Platform="windows" Architecture="x64" />
     <SPMI_Partition Include="win-arm64" Platform="windows" Architecture="arm64" />
     <SPMI_Partition Include="unix-x64" Platform="Linux" Architecture="x64" />
-    <SPMI_Partition Include="unix-arm64" Platform="Linux" Architecture="arm64" />
+    <SPMI_Partition Include="linux-arm64" Platform="Linux" Architecture="arm64" />
+    <SPMI_Partition Include="osx-arm64" Platform="OSX" Architecture="arm64" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(Architecture)' == 'x86'">
diff --git a/src/coreclr/scripts/superpmi-collect.proj b/src/coreclr/scripts/superpmi-collect.proj
index 046a699917fc62..4a6edd8b5923b8 100644
--- a/src/coreclr/scripts/superpmi-collect.proj
+++ b/src/coreclr/scripts/superpmi-collect.proj
@@ -42,6 +42,11 @@
          PmiAssembliesPayload - Path that will be sent to helix machine to run collection on
          PmiAssembliesDirectory - Path on helix machine itself where superpmi.py will discover the sent assemblies.
     -->
+
+  <ItemGroup>
+    <PmiPathDirectories Include="$([System.IO.Directory]::GetDirectories($(SuperPMIDirectory)))" />
+  </ItemGroup>
+
   <PropertyGroup Condition="'$(AGENT_OS)' == 'Windows_NT'">
     <Python>%HELIX_PYTHONPATH%</Python>
     <PmiAssembliesPayload>$(WorkItemDirectory)\pmiAssembliesDirectory</PmiAssembliesPayload>
@@ -54,7 +59,7 @@
     <OutputMchPath>%HELIX_WORKITEM_UPLOAD_ROOT%</OutputMchPath>
     <!-- Workaround until https://github.com/dotnet/arcade/pull/6179 is not available -->
     <HelixResultsDestinationDir>$(BUILD_SOURCESDIRECTORY)\artifacts\helixresults</HelixResultsDestinationDir>
-    <WorkItemCommand>$(SuperPMIDirectory)\superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)\pmi.dll -pmi_path $(SuperPMIDirectory)\crossgen2</WorkItemCommand>
+    <WorkItemCommand>$(SuperPMIDirectory)\superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)\pmi.dll -pmi_path @(PmiPathDirectories->'%(FullPath)', ' ')</WorkItemCommand>
   </PropertyGroup>
   <PropertyGroup Condition="'$(AGENT_OS)' != 'Windows_NT'">
     <Python>$HELIX_PYTHONPATH</Python>
@@ -68,7 +73,7 @@
     <OutputMchPath>$HELIX_WORKITEM_UPLOAD_ROOT</OutputMchPath>
     <!-- Workaround until https://github.com/dotnet/arcade/pull/6179 is not available -->
     <HelixResultsDestinationDir>$(BUILD_SOURCESDIRECTORY)/artifacts/helixresults</HelixResultsDestinationDir>
-    <WorkItemCommand>$(SuperPMIDirectory)/superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)/pmi.dll -pmi_path $(SuperPMIDirectory)/crossgen2</WorkItemCommand>
+    <WorkItemCommand>$(SuperPMIDirectory)/superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)/pmi.dll -pmi_path @(PmiPathDirectories->'%(FullPath)', ' ')</WorkItemCommand>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(WorkItemCommand)' != ''">
diff --git a/src/coreclr/scripts/superpmi-replay.proj b/src/coreclr/scripts/superpmi-replay.proj
index e76a4a3d810e5d..cac87c580fdde4 100644
--- a/src/coreclr/scripts/superpmi-replay.proj
+++ b/src/coreclr/scripts/superpmi-replay.proj
@@ -55,7 +55,8 @@
     <SPMI_Partition Include="win-x64" Platform="windows" Architecture="x64" />
     <SPMI_Partition Include="win-arm64" Platform="windows" Architecture="arm64" />
     <SPMI_Partition Include="unix-x64" Platform="Linux" Architecture="x64" />
-    <SPMI_Partition Include="unix-arm64" Platform="Linux" Architecture="arm64" />
+    <SPMI_Partition Include="linux-arm64" Platform="Linux" Architecture="arm64" />
+    <SPMI_Partition Include="osx-arm64" Platform="OSX" Architecture="arm64" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(Architecture)' == 'x86'">

From 9d360c9aa24a61da9fc769644102da1b71179911 Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Sun, 23 Jan 2022 14:23:32 -0800
Subject: [PATCH 012/161] Update NativeAOT codegen and Crossgen2 for CreateSpan
 (#63977)

- Make sure FieldRVA pointers remain aligned as required by the code generator
  - Use the same Packing Size approach as the IL Linker will use (See jbevain/cecil#817 for details)
  - Compilers that generate CreateSpan will need to follow that trick to be compatible with rewriters.
- Provide ECMA spec augment describing packing size detail
---
 docs/design/specs/Ecma-335-Augments.md                 | 10 ++++++++++
 .../aot/ILCompiler.Compiler/Compiler/Compilation.cs    |  3 ++-
 .../ReadyToRun/CopiedFieldRvaNode.cs                   |  9 ++++++---
 src/tests/JIT/Intrinsics/CreateSpan_il.il              |  2 +-
 4 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/docs/design/specs/Ecma-335-Augments.md b/docs/design/specs/Ecma-335-Augments.md
index 1c52fedd4d84ce..6e1900c1dc6bd0 100644
--- a/docs/design/specs/Ecma-335-Augments.md
+++ b/docs/design/specs/Ecma-335-Augments.md
@@ -13,6 +13,7 @@ This is a list of additions and edits to be made in ECMA-335 specifications. It
 - [Static Interface Methods](#static-interface-methods)
 - [Covariant Return Types](#covariant-return-types)
 - [Unsigned data conversion with overflow detection](#unsigned-data-conversion-with-overflow-detection)
+- [Rules for IL rewriters](#rules-for-il-rewriters)
 
 ## Signatures
 
@@ -948,3 +949,12 @@ Conversions from floating-point numbers to integral values truncate the number t
 on the top of the stack is reinterpreted as an unsigned value before the conversion.
 Note that integer values of less than 4 bytes are extended to int32 (not native int) on the
 evaluation stack.
+
+## Rules for IL Rewriters
+
+There are apis such as `System.Runtime.CompilerServices.RuntimeHelpers.CreateSpan<T>(...)` which require that the PE file have a particular structure. In particular, that api requires that the associated RVA of a FieldDef which is used to create a span must be naturally aligned over the data type that `CreateSpan` is instantiated over. There are 2 major concerns.
+
+1. That the RVA be aligned when the PE file is constructed. This may be achieved by whatever means is most convenient for the compiler.
+2. That in the presence of IL rewriters that the RVA remains aligned. This section descibes metadata which will be processed by IL rewriters in order to maintain the required alignment.
+
+In order to maintain alignment, if the field needs alignment to be preserved, the field must be of a type locally defined within the module which has a Pack (§II.10.7) value of the desired alignment. Unlike other uses of the .pack directive, in this circumstance the .pack specifies a minimum alignment.
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
index f3f780e87e060b..d19b60b104c242 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
@@ -143,8 +143,9 @@ public virtual ISymbolNode GetFieldRvaData(FieldDesc field)
             {
                 // Use the typical field definition in case this is an instantiated generic type
                 field = field.GetTypicalFieldDefinition();
+                int fieldTypePack = (field.FieldType as MetadataType)?.GetClassLayout().PackingSize ?? 1;
                 return NodeFactory.ReadOnlyDataBlob(NameMangler.GetMangledFieldName(field),
-                    ((EcmaField)field).GetFieldRvaData(), NodeFactory.Target.PointerSize);
+                    ((EcmaField)field).GetFieldRvaData(), Math.Max(NodeFactory.Target.PointerSize, fieldTypePack));
             }
         }
 
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/CopiedFieldRvaNode.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/CopiedFieldRvaNode.cs
index e8596cf24c894a..a8ff518ac7591e 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/CopiedFieldRvaNode.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/CopiedFieldRvaNode.cs
@@ -46,15 +46,17 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
             }
 
             ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
-            builder.RequireInitialPointerAlignment();
+            byte[] rvaData = GetRvaData(factory.Target.PointerSize, out int requiredAlignment);
+            builder.RequireInitialAlignment(requiredAlignment);
             builder.AddSymbol(this);
-            builder.EmitBytes(GetRvaData(factory.Target.PointerSize));
+            builder.EmitBytes(rvaData);
             return builder.ToObjectData();
         }
 
-        private unsafe byte[] GetRvaData(int targetPointerSize)
+        private unsafe byte[] GetRvaData(int targetPointerSize, out int requiredAlignment)
         {
             int size = 0;
+            requiredAlignment = targetPointerSize;
 
             MetadataReader metadataReader = _module.MetadataReader;
             BlobReader metadataBlob = new BlobReader(_module.PEReader.GetMetadata().Pointer, _module.PEReader.GetMetadata().Length);
@@ -80,6 +82,7 @@ private unsafe byte[] GetRvaData(int targetPointerSize)
                 Debug.Assert(field.HasRva);
 
                 int currentSize = field.FieldType.GetElementSize().AsInt;
+                requiredAlignment = Math.Max(requiredAlignment, (field.FieldType as MetadataType)?.GetClassLayout().PackingSize ?? 1);
                 if (currentSize > size)
                 {
                     // We need to handle overlapping fields by reusing blobs based on the rva, and just update
diff --git a/src/tests/JIT/Intrinsics/CreateSpan_il.il b/src/tests/JIT/Intrinsics/CreateSpan_il.il
index d6a269b6f4d5f4..cd950298337bb8 100644
--- a/src/tests/JIT/Intrinsics/CreateSpan_il.il
+++ b/src/tests/JIT/Intrinsics/CreateSpan_il.il
@@ -100,7 +100,7 @@
   .class explicit ansi sealed nested private '__StaticArrayInitTypeSize=16'
          extends [System.Runtime]System.ValueType
   {
-    .pack 1
+    .pack 4
     .size 16
   } // end of class '__StaticArrayInitTypeSize=16'
 

From 352a6b8d0ded088314e572303e7fec6ac0684c51 Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Sun, 23 Jan 2022 14:25:26 -0800
Subject: [PATCH 013/161] Add alignment to mapped field stream (#63305)

* Align MappeFieldDataStream at 8 byte boundary

* Add test to verify that the mapped field rva data blob is aligned to ManagedPEBuilder.MappedFieldDataAlignment

* Only align when the mapped field data is of size not equal to 0
---
 .../PortableExecutable/ManagedTextSection.cs  | 16 ++-
 .../PortableExecutable/PEBuilderTests.cs      | 98 ++++++++++++++++++-
 2 files changed, 110 insertions(+), 4 deletions(-)

diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/PortableExecutable/ManagedTextSection.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/PortableExecutable/ManagedTextSection.cs
index 33bd80dec21f75..1762b12d928ba0 100644
--- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/PortableExecutable/ManagedTextSection.cs
+++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/PortableExecutable/ManagedTextSection.cs
@@ -121,7 +121,7 @@ public ManagedTextSection(
 
         public const int MappedFieldDataAlignment = 8;
 
-        public int CalculateOffsetToMappedFieldDataStream()
+        internal int CalculateOffsetToMappedFieldDataStreamUnaligned()
         {
             int result = ComputeOffsetToImportTable();
 
@@ -135,6 +135,16 @@ public int CalculateOffsetToMappedFieldDataStream()
             return result;
         }
 
+        public int CalculateOffsetToMappedFieldDataStream()
+        {
+             int result = CalculateOffsetToMappedFieldDataStreamUnaligned();
+             if (MappedFieldDataSize != 0)
+             {
+                 result = BitArithmetic.Align(result, MappedFieldDataAlignment);
+             }
+             return result;
+        }
+
         internal int ComputeOffsetToDebugDirectory()
         {
             Debug.Assert(MetadataSize % 4 == 0);
@@ -185,7 +195,7 @@ public int GetEntryPointAddress(int rva)
         {
             // TODO: constants
             return RequiresStartupStub ?
-                rva + CalculateOffsetToMappedFieldDataStream() - (Is32Bit ? 6 : 10) :
+                rva + CalculateOffsetToMappedFieldDataStreamUnaligned() - (Is32Bit ? 6 : 10) :
                 0;
         }
 
@@ -293,6 +303,8 @@ public void Serialize(
             // mapped field data:
             if (mappedFieldDataBuilderOpt != null)
             {
+                if (mappedFieldDataBuilderOpt.Count != 0)
+                    builder.Align(MappedFieldDataAlignment);
                 builder.LinkSuffix(mappedFieldDataBuilderOpt);
             }
 
diff --git a/src/libraries/System.Reflection.Metadata/tests/PortableExecutable/PEBuilderTests.cs b/src/libraries/System.Reflection.Metadata/tests/PortableExecutable/PEBuilderTests.cs
index 763e26dbc1811c..c3dab37bbd3590 100644
--- a/src/libraries/System.Reflection.Metadata/tests/PortableExecutable/PEBuilderTests.cs
+++ b/src/libraries/System.Reflection.Metadata/tests/PortableExecutable/PEBuilderTests.cs
@@ -64,7 +64,8 @@ private static void WritePEImage(
             Blob mvidFixup = default(Blob),
             byte[] privateKeyOpt = null,
             bool publicSigned = false,
-            Machine machine = 0)
+            Machine machine = 0,
+            BlobBuilder? mappedFieldData = null)
         {
             var peHeaderBuilder = new PEHeaderBuilder(imageCharacteristics: entryPointHandle.IsNil ? Characteristics.Dll : Characteristics.ExecutableImage,
                                                       machine: machine);
@@ -75,7 +76,8 @@ private static void WritePEImage(
                 ilBuilder,
                 entryPoint: entryPointHandle,
                 flags: CorFlags.ILOnly | (privateKeyOpt != null || publicSigned ? CorFlags.StrongNameSigned : 0),
-                deterministicIdProvider: content => s_contentId);
+                deterministicIdProvider: content => s_contentId,
+                mappedFieldData: mappedFieldData);
 
             var peBlob = new BlobBuilder();
 
@@ -487,6 +489,98 @@ private static MethodDefinitionHandle ComplexEmit(MetadataBuilder metadata, Blob
             return default(MethodDefinitionHandle);
         }
 
+        [Theory] // Validate FieldRVA alignment on common machine types
+        [MemberData(nameof(AllMachineTypes))]
+        public void FieldRVAAlignmentVerify(Machine machine)
+        {
+            using (var peStream = new MemoryStream())
+            {
+                var ilBuilder = new BlobBuilder();
+                var mappedRVADataBuilder = new BlobBuilder();
+                var metadataBuilder = new MetadataBuilder();
+                double validationNumber = 0.100001;
+                var fieldDef = FieldRVAValidationEmit(metadataBuilder, mappedRVADataBuilder, validationNumber);
+
+                WritePEImage(peStream, metadataBuilder, ilBuilder, default(MethodDefinitionHandle),
+                    mappedFieldData: mappedRVADataBuilder,
+                    machine: machine);
+
+                // Validate FieldRVA is aligned as ManagedPEBuilder.MappedFieldDataAlignemnt
+                peStream.Position = 0;
+                using (var peReader = new PEReader(peStream, PEStreamOptions.LeaveOpen))
+                {
+                    var mdReader = peReader.GetMetadataReader();
+
+                    // Validate that there is only 1 field rva entry
+                    Assert.Equal(1, mdReader.FieldRvaTable.NumberOfRows);
+
+                    // Validate that the RVA is aligned properly (which should be at least an 8 byte alignment
+                    Assert.Equal(0, mdReader.FieldRvaTable.GetRva(1) % ManagedPEBuilder.MappedFieldDataAlignment);
+
+                    // Validate that the correct data is at the RVA
+                    var fieldRVAData = peReader.GetSectionData(mdReader.FieldRvaTable.GetRva(1));
+                    Assert.Equal(validationNumber, fieldRVAData.GetReader().ReadDouble());
+                }
+
+                VerifyPE(peStream, machine);
+            }
+        }
+
+        private static FieldDefinitionHandle FieldRVAValidationEmit(MetadataBuilder metadata, BlobBuilder mappedRVAData, double doubleToWriteAsData)
+        {
+            metadata.AddModule(
+                0,
+                metadata.GetOrAddString("ConsoleApplication.exe"),
+                metadata.GetOrAddGuid(s_guid),
+                default(GuidHandle),
+                default(GuidHandle));
+
+            metadata.AddAssembly(
+                metadata.GetOrAddString("ConsoleApplication"),
+                version: new Version(1, 0, 0, 0),
+                culture: default(StringHandle),
+                publicKey: metadata.GetOrAddBlob(ImmutableArray.Create(Misc.KeyPair_PublicKey)),
+                flags: AssemblyFlags.PublicKey,
+                hashAlgorithm: AssemblyHashAlgorithm.Sha1);
+
+            var mscorlibAssemblyRef = metadata.AddAssemblyReference(
+                name: metadata.GetOrAddString("mscorlib"),
+                version: new Version(4, 0, 0, 0),
+                culture: default(StringHandle),
+                publicKeyOrToken: metadata.GetOrAddBlob(ImmutableArray.Create<byte>(0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89)),
+                flags: default(AssemblyFlags),
+                hashValue: default(BlobHandle));
+
+            var systemObjectTypeRef = metadata.AddTypeReference(
+                mscorlibAssemblyRef,
+                metadata.GetOrAddString("System"),
+                metadata.GetOrAddString("Object"));
+
+            mappedRVAData.WriteDouble(doubleToWriteAsData);
+
+            var rvaFieldSignature = new BlobBuilder();
+
+            new BlobEncoder(rvaFieldSignature).
+                FieldSignature().Double();
+
+            var fieldRVADef = metadata.AddFieldDefinition(
+            FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.HasFieldRVA,
+            metadata.GetOrAddString("RvaField"),
+            metadata.GetOrAddBlob(rvaFieldSignature));
+
+            metadata.AddFieldRelativeVirtualAddress(fieldRVADef, 0);
+
+            metadata.AddTypeDefinition(
+                TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
+                metadata.GetOrAddString("ConsoleApplication"),
+                metadata.GetOrAddString("Program"),
+                systemObjectTypeRef,
+                fieldList: fieldRVADef,
+                methodList: MetadataTokens.MethodDefinitionHandle(1));
+
+            return fieldRVADef;
+        }
+
         private class TestResourceSectionBuilder : ResourceSectionBuilder
         {
             public TestResourceSectionBuilder()

From 1f2116cd60ec0f3e39abbf60d7feedc537e5dfd3 Mon Sep 17 00:00:00 2001
From: Kevin Jones <kevin@vcsjones.com>
Date: Sun, 23 Jan 2022 18:23:24 -0500
Subject: [PATCH 014/161] Implement hash and HMAC stream one shots

This implements hashing and HMAC statics for streams. Additionally,
"LiteHmac" and "LiteHash" were introduced. The existing HMAC and hash
provider functionality do some bookkeeping we don't need for resetting.
Since we do not need to use these hash handles after the digest has
been finalized, resetting is unnecessary work. For HMAC, that also means
keeping a copy of the key around for some implementations which we don't
need to do.

The LiteHash and LiteHmac types are implemented as structs with a common
interface. To avoid boxing, generics are used and constrained to the interface
where possible.

The Browser implementation just defers to the existing HashDispenser rather
than do anything novel.

The HashProviderCng is somewhat specialized in its ability to reset. It did
up-front check to determine if the platform supported reusable hash providers,
and further had a single implementation for HMAC and Digests. The current
Lite hash design requires that they remain separate types.
---
 .../Interop.Hmac.cs                           |  10 +-
 .../ref/System.Security.Cryptography.cs       |  50 ++++
 .../src/System.Security.Cryptography.csproj   |   7 +
 .../System/Security/Cryptography/HMACMD5.cs   | 172 ++++++++++++++
 .../System/Security/Cryptography/HMACSHA1.cs  | 173 +++++++++++++-
 .../Security/Cryptography/HMACSHA256.cs       | 173 +++++++++++++-
 .../Security/Cryptography/HMACSHA384.cs       | 176 +++++++++++++-
 .../Security/Cryptography/HMACSHA512.cs       | 176 +++++++++++++-
 .../Cryptography/HashAlgorithmNames.Apple.cs  |  19 ++
 .../Cryptography/HashAlgorithmNames.cs        |   2 +-
 .../HashProviderDispenser.Apple.cs            | 209 +++++-----------
 .../HashProviderDispenser.OpenSsl.cs          | 130 +++-------
 .../Security/Cryptography/LiteHash.Apple.cs   | 215 +++++++++++++++++
 .../Security/Cryptography/LiteHash.Browser.cs |  57 +++++
 .../Security/Cryptography/LiteHash.Unix.cs    | 174 ++++++++++++++
 .../Security/Cryptography/LiteHash.Windows.cs | 173 ++++++++++++++
 .../Security/Cryptography/LiteHashProvider.cs | 195 +++++++++++++++
 .../src/System/Security/Cryptography/MD5.cs   | 125 ++++++++++
 .../src/System/Security/Cryptography/SHA1.cs  | 125 ++++++++++
 .../System/Security/Cryptography/SHA256.cs    | 125 ++++++++++
 .../System/Security/Cryptography/SHA384.cs    | 125 ++++++++++
 .../System/Security/Cryptography/SHA512.cs    | 125 ++++++++++
 .../tests/HashAlgorithmTestDriver.cs          | 223 +++++++++++-------
 .../tests/HmacMD5Tests.cs                     | 100 ++++++++
 .../tests/HmacSha1Tests.cs                    | 102 +++++++-
 .../tests/HmacSha256Tests.cs                  | 102 +++++++-
 .../tests/HmacSha384Tests.cs                  | 102 +++++++-
 .../tests/HmacSha512Tests.cs                  | 102 +++++++-
 .../tests/HmacTests.cs                        | 221 +++++++++++++++++
 .../tests/MD5Tests.cs                         |  64 +++++
 .../tests/Sha1Tests.cs                        |  70 ++++++
 .../tests/Sha256Tests.cs                      |  79 +++++++
 .../tests/Sha384Tests.cs                      |  78 +++++-
 .../tests/Sha512Tests.cs                      |  85 +++++++
 .../tests/StreamHelpers.cs                    | 147 ++++++++++++
 .../System.Security.Cryptography.Tests.csproj |   1 +
 36 files changed, 3860 insertions(+), 352 deletions(-)
 create mode 100644 src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.Apple.cs
 create mode 100644 src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs
 create mode 100644 src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs
 create mode 100644 src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs
 create mode 100644 src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs
 create mode 100644 src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHashProvider.cs
 create mode 100644 src/libraries/System.Security.Cryptography/tests/StreamHelpers.cs

diff --git a/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.Hmac.cs b/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.Hmac.cs
index 6cf3766ad8ed53..993d6d42ae7517 100644
--- a/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.Hmac.cs
+++ b/src/libraries/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.Hmac.cs
@@ -16,7 +16,15 @@ internal static partial class AppleCrypto
         internal static partial SafeHmacHandle HmacCreate(PAL_HashAlgorithm algorithm, ref int cbDigest);
 
         [GeneratedDllImport(Libraries.AppleCryptoNative, EntryPoint = "AppleCryptoNative_HmacInit")]
-        internal static partial int HmacInit(SafeHmacHandle ctx, byte[] pbKey, int cbKey);
+        private static unsafe partial int HmacInit(SafeHmacHandle ctx, byte* pbKey, int cbKey);
+
+        internal static unsafe int HmacInit(SafeHmacHandle ctx, ReadOnlySpan<byte> key)
+        {
+            fixed (byte* pKey = &MemoryMarshal.GetReference(key))
+            {
+                return HmacInit(ctx, pKey, key.Length);
+            }
+        }
 
         internal static int HmacUpdate(SafeHmacHandle ctx, ReadOnlySpan<byte> data) =>
             HmacUpdate(ctx, ref MemoryMarshal.GetReference(data), data.Length);
diff --git a/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs b/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs
index be3a8b7bb3b0b3..e671b178a816b0 100644
--- a/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs
+++ b/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs
@@ -681,8 +681,14 @@ protected override void Dispose(bool disposing) { }
         protected override void HashCore(byte[] rgb, int ib, int cb) { }
         protected override void HashCore(System.ReadOnlySpan<byte> source) { }
         public static byte[] HashData(byte[] key, byte[] source) { throw null; }
+        public static byte[] HashData(byte[] key, System.IO.Stream source) { throw null; }
+        public static byte[] HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source) { throw null; }
+        public static int HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(byte[] key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         protected override byte[] HashFinal() { throw null; }
         public override void Initialize() { }
         public static bool TryHashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
@@ -703,8 +709,14 @@ protected override void Dispose(bool disposing) { }
         protected override void HashCore(byte[] rgb, int ib, int cb) { }
         protected override void HashCore(System.ReadOnlySpan<byte> source) { }
         public static byte[] HashData(byte[] key, byte[] source) { throw null; }
+        public static byte[] HashData(byte[] key, System.IO.Stream source) { throw null; }
+        public static byte[] HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source) { throw null; }
+        public static int HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(byte[] key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         protected override byte[] HashFinal() { throw null; }
         public override void Initialize() { }
         public static bool TryHashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
@@ -722,8 +734,14 @@ protected override void Dispose(bool disposing) { }
         protected override void HashCore(byte[] rgb, int ib, int cb) { }
         protected override void HashCore(System.ReadOnlySpan<byte> source) { }
         public static byte[] HashData(byte[] key, byte[] source) { throw null; }
+        public static byte[] HashData(byte[] key, System.IO.Stream source) { throw null; }
+        public static byte[] HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source) { throw null; }
+        public static int HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(byte[] key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         protected override byte[] HashFinal() { throw null; }
         public override void Initialize() { }
         public static bool TryHashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
@@ -743,8 +761,14 @@ protected override void Dispose(bool disposing) { }
         protected override void HashCore(byte[] rgb, int ib, int cb) { }
         protected override void HashCore(System.ReadOnlySpan<byte> source) { }
         public static byte[] HashData(byte[] key, byte[] source) { throw null; }
+        public static byte[] HashData(byte[] key, System.IO.Stream source) { throw null; }
+        public static byte[] HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source) { throw null; }
+        public static int HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(byte[] key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         protected override byte[] HashFinal() { throw null; }
         public override void Initialize() { }
         public static bool TryHashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
@@ -764,8 +788,14 @@ protected override void Dispose(bool disposing) { }
         protected override void HashCore(byte[] rgb, int ib, int cb) { }
         protected override void HashCore(System.ReadOnlySpan<byte> source) { }
         public static byte[] HashData(byte[] key, byte[] source) { throw null; }
+        public static byte[] HashData(byte[] key, System.IO.Stream source) { throw null; }
+        public static byte[] HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source) { throw null; }
+        public static int HashData(System.ReadOnlySpan<byte> key, System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(byte[] key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.ReadOnlyMemory<byte> key, System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         protected override byte[] HashFinal() { throw null; }
         public override void Initialize() { }
         public static bool TryHashData(System.ReadOnlySpan<byte> key, System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
@@ -834,8 +864,12 @@ protected MD5() { }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The default algorithm implementations might be removed, use strong type references like 'RSA.Create()' instead.")]
         public static new System.Security.Cryptography.MD5? Create(string algName) { throw null; }
         public static byte[] HashData(byte[] source) { throw null; }
+        public static byte[] HashData(System.IO.Stream source) { throw null; }
+        public static int HashData(System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public static bool TryHashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     public sealed partial class Oid
@@ -1197,8 +1231,12 @@ protected SHA1() { }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The default algorithm implementations might be removed, use strong type references like 'RSA.Create()' instead.")]
         public static new System.Security.Cryptography.SHA1? Create(string hashName) { throw null; }
         public static byte[] HashData(byte[] source) { throw null; }
+        public static byte[] HashData(System.IO.Stream source) { throw null; }
+        public static int HashData(System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public static bool TryHashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.ObsoleteAttribute("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId = "SYSLIB0021", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
@@ -1222,8 +1260,12 @@ protected SHA256() { }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The default algorithm implementations might be removed, use strong type references like 'RSA.Create()' instead.")]
         public static new System.Security.Cryptography.SHA256? Create(string hashName) { throw null; }
         public static byte[] HashData(byte[] source) { throw null; }
+        public static byte[] HashData(System.IO.Stream source) { throw null; }
+        public static int HashData(System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public static bool TryHashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.ObsoleteAttribute("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId = "SYSLIB0021", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
@@ -1247,8 +1289,12 @@ protected SHA384() { }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The default algorithm implementations might be removed, use strong type references like 'RSA.Create()' instead.")]
         public static new System.Security.Cryptography.SHA384? Create(string hashName) { throw null; }
         public static byte[] HashData(byte[] source) { throw null; }
+        public static byte[] HashData(System.IO.Stream source) { throw null; }
+        public static int HashData(System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public static bool TryHashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.ObsoleteAttribute("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId = "SYSLIB0021", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
@@ -1272,8 +1318,12 @@ protected SHA512() { }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The default algorithm implementations might be removed, use strong type references like 'RSA.Create()' instead.")]
         public static new System.Security.Cryptography.SHA512? Create(string hashName) { throw null; }
         public static byte[] HashData(byte[] source) { throw null; }
+        public static byte[] HashData(System.IO.Stream source) { throw null; }
+        public static int HashData(System.IO.Stream source, System.Span<byte> destination) { throw null; }
         public static byte[] HashData(System.ReadOnlySpan<byte> source) { throw null; }
         public static int HashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination) { throw null; }
+        public static System.Threading.Tasks.ValueTask<int> HashDataAsync(System.IO.Stream source, System.Memory<byte> destination, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public static System.Threading.Tasks.ValueTask<byte[]> HashDataAsync(System.IO.Stream source, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public static bool TryHashData(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
     [System.ObsoleteAttribute("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId = "SYSLIB0021", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
diff --git a/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj b/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj
index 9a268d9a83d9a0..a2a2d2d52ca21c 100644
--- a/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj
+++ b/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj
@@ -278,6 +278,7 @@
     <Compile Include="System\Security\Cryptography\IncrementalHash.cs" />
     <Compile Include="System\Security\Cryptography\KeyedHashAlgorithm.cs" />
     <Compile Include="System\Security\Cryptography\KeySizes.cs" />
+    <Compile Include="System\Security\Cryptography\LiteHashProvider.cs" />
     <Compile Include="System\Security\Cryptography\MaskGenerationMethod.cs" />
     <Compile Include="System\Security\Cryptography\MD5.cs" />
     <Compile Include="System\Security\Cryptography\Oid.cs" />
@@ -378,6 +379,7 @@
     <Compile Include="System\Security\Cryptography\RSA.Create.NotSupported.cs" />
     <Compile Include="System\Security\Cryptography\SHAHashProvider.Browser.cs" />
     <Compile Include="System\Security\Cryptography\TripleDesImplementation.NotSupported.cs" />
+    <Compile Include="System\Security\Cryptography\LiteHash.Browser.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(NeedOpenSslInitializer)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Unix\Interop.Libraries.cs"
@@ -482,6 +484,7 @@
     <Compile Include="System\Security\Cryptography\RandomNumberGeneratorImplementation.OpenSsl.cs" />
     <Compile Include="System\Security\Cryptography\RC2Implementation.OpenSsl.cs" />
     <Compile Include="System\Security\Cryptography\TripleDesImplementation.OpenSsl.cs" />
+    <Compile Include="System\Security\Cryptography\LiteHash.Unix.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(UseOpenSslAead)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSslAvailable.cs"
@@ -571,6 +574,7 @@
     <Compile Include="System\Security\Cryptography\RC2Implementation.NotSupported.cs" />
     <Compile Include="System\Security\Cryptography\RSA.Create.Android.cs" />
     <Compile Include="System\Security\Cryptography\TripleDesImplementation.OpenSsl.cs" />
+    <Compile Include="System\Security\Cryptography\LiteHash.Unix.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(UseAppleCrypto)' == 'true'">
     <Compile Include="$(CommonPath)Internal\Cryptography\AsymmetricAlgorithmHelpers.Ansi.cs"
@@ -637,9 +641,11 @@
     <Compile Include="System\Security\Cryptography\DesImplementation.Apple.cs" />
     <Compile Include="System\Security\Cryptography\ECDiffieHellman.Create.SecurityTransforms.cs" />
     <Compile Include="System\Security\Cryptography\HashProviderDispenser.Apple.cs" />
+    <Compile Include="System\Security\Cryptography\LiteHash.Apple.cs" />
     <Compile Include="System\Security\Cryptography\RandomNumberGeneratorImplementation.Apple.cs" />
     <Compile Include="System\Security\Cryptography\RC2Implementation.Apple.cs" />
     <Compile Include="System\Security\Cryptography\TripleDesImplementation.Apple.cs" />
+    <Compile Include="System\Security\Cryptography\HashAlgorithmNames.Apple.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsOSX)' == 'true'">
     <Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.Pbkdf2.cs"
@@ -840,6 +846,7 @@
     <Compile Include="System\Security\Cryptography\RC2Implementation.Windows.cs" />
     <Compile Include="System\Security\Cryptography\RSACng.cs" />
     <Compile Include="System\Security\Cryptography\TripleDesImplementation.Windows.cs" />
+    <Compile Include="System\Security\Cryptography\LiteHash.Windows.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System.Collections" />
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACMD5.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACMD5.cs
index 97067a63b3f93c..eff5baa635b8d6 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACMD5.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACMD5.cs
@@ -2,7 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.IO;
 using System.Runtime.Versioning;
+using System.Threading;
+using System.Threading.Tasks;
 using Internal.Cryptography;
 
 namespace System.Security.Cryptography
@@ -162,6 +165,175 @@ public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source
             return true;
         }
 
+        /// <summary>
+        /// Computes the HMAC of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated HMAC
+        ///   size. The MD5 algorithm always produces a 128-bit HMAC, or 16 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.MD5, HashSizeInBytes, key, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(ReadOnlySpan<byte> key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.MD5, HashSizeInBytes, key, source);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(byte[] key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+            return HashData(new ReadOnlySpan<byte>(key), source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(HashAlgorithmNames.MD5, HashSizeInBytes, key.Span, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+
+            return HashDataAsync(new ReadOnlyMemory<byte>(key), source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The MD5 algorithm always produces a 128-bit hash, or 16 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(
+                HashAlgorithmNames.MD5,
+                HashSizeInBytes,
+                key.Span,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA1.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA1.cs
index 006898d72c6ac7..cc8d5619da2084 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA1.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA1.cs
@@ -2,10 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Internal.Cryptography;
-using System;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.IO;
 using System.Runtime.Versioning;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace System.Security.Cryptography
 {
@@ -171,6 +173,175 @@ public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source
             return true;
         }
 
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated HMAC
+        ///   size. The SHA1 algorithm always produces a 160-bit HMAC, or 20 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA1, HashSizeInBytes, key, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(ReadOnlySpan<byte> key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA1, HashSizeInBytes, key, source);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(byte[] key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+            return HashData(new ReadOnlySpan<byte>(key), source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(HashAlgorithmNames.SHA1, HashSizeInBytes, key.Span, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+
+            return HashDataAsync(new ReadOnlyMemory<byte>(key), source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA1 algorithm always produces a 160-bit hash, or 20 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(
+                HashAlgorithmNames.SHA1,
+                HashSizeInBytes,
+                key.Span,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA256.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA256.cs
index 0cb3ff2ab423da..797f60dd3b49b0 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA256.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA256.cs
@@ -3,8 +3,10 @@
 
 using Internal.Cryptography;
 using System.Diagnostics;
+using System.IO;
 using System.Runtime.Versioning;
-using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace System.Security.Cryptography
 {
@@ -163,6 +165,175 @@ public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source
             return true;
         }
 
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated HMAC
+        ///   size. The SHA256 algorithm always produces a 256-bit HMAC, or 32 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA256, HashSizeInBytes, key, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(ReadOnlySpan<byte> key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA256, HashSizeInBytes, key, source);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(byte[] key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+            return HashData(new ReadOnlySpan<byte>(key), source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(HashAlgorithmNames.SHA256, HashSizeInBytes, key.Span, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+
+            return HashDataAsync(new ReadOnlyMemory<byte>(key), source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA256 algorithm always produces a 256-bit hash, or 32 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(
+                HashAlgorithmNames.SHA256,
+                HashSizeInBytes,
+                key.Span,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA384.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA384.cs
index db9781f1fea2b1..1162850933c35e 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA384.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA384.cs
@@ -1,11 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Internal.Cryptography;
-using System;
 using System.Diagnostics;
+using System.IO;
 using System.Runtime.Versioning;
-using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Internal.Cryptography;
 
 namespace System.Security.Cryptography
 {
@@ -181,6 +182,175 @@ public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source
             return true;
         }
 
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated HMAC
+        ///   size. The SHA384 algorithm always produces a 384-bit HMAC, or 48 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA384, HashSizeInBytes, key, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(ReadOnlySpan<byte> key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA384, HashSizeInBytes, key, source);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(byte[] key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+            return HashData(new ReadOnlySpan<byte>(key), source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(HashAlgorithmNames.SHA384, HashSizeInBytes, key.Span, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+
+            return HashDataAsync(new ReadOnlyMemory<byte>(key), source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA384 algorithm always produces a 384-bit hash, or 48 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(
+                HashAlgorithmNames.SHA384,
+                HashSizeInBytes,
+                key.Span,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA512.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA512.cs
index ee743669edf8ae..079798b459a2b7 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA512.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HMACSHA512.cs
@@ -1,11 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Internal.Cryptography;
-using System;
 using System.Diagnostics;
+using System.IO;
 using System.Runtime.Versioning;
-using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Internal.Cryptography;
 
 namespace System.Security.Cryptography
 {
@@ -178,6 +179,175 @@ public static bool TryHashData(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source
             return true;
         }
 
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated HMAC
+        ///   size. The SHA512 algorithm always produces a 512-bit HMAC, or 64 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(ReadOnlySpan<byte> key, Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA512, HashSizeInBytes, key, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(ReadOnlySpan<byte> key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStream(HashAlgorithmNames.SHA512, HashSizeInBytes, key, source);
+        }
+
+        /// <summary>
+        /// Computes the HMAC of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(byte[] key, Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+            return HashData(new ReadOnlySpan<byte>(key), source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(ReadOnlyMemory<byte> key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(HashAlgorithmNames.SHA512, HashSizeInBytes, key.Span, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The HMAC of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="key" /> or <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(byte[] key, Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(key);
+
+            return HashDataAsync(new ReadOnlyMemory<byte>(key), source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the HMAC of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="key">The HMAC key.</param>
+        /// <param name="source">The stream to HMAC.</param>
+        /// <param name="destination">The buffer to receive the HMAC value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA512 algorithm always produces a 512-bit hash, or 64 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HmacStreamAsync(
+                HashAlgorithmNames.SHA512,
+                HashSizeInBytes,
+                key.Span,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         protected override void Dispose(bool disposing)
         {
             if (disposing)
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.Apple.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.Apple.cs
new file mode 100644
index 00000000000000..3cc658ee231648
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.Apple.cs
@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using PAL_HashAlgorithm = Interop.AppleCrypto.PAL_HashAlgorithm;
+
+namespace System.Security.Cryptography
+{
+    internal static partial class HashAlgorithmNames
+    {
+        internal static PAL_HashAlgorithm HashAlgorithmToPal(string hashAlgorithmId) => hashAlgorithmId switch {
+            HashAlgorithmNames.MD5 => PAL_HashAlgorithm.Md5,
+            HashAlgorithmNames.SHA1 => PAL_HashAlgorithm.Sha1,
+            HashAlgorithmNames.SHA256 => PAL_HashAlgorithm.Sha256,
+            HashAlgorithmNames.SHA384 => PAL_HashAlgorithm.Sha384,
+            HashAlgorithmNames.SHA512 => PAL_HashAlgorithm.Sha512,
+            _ => throw new CryptographicException(SR.Format(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithmId))
+        };
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.cs
index dc0a42f78ac8d3..24cb46bdc2fd50 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashAlgorithmNames.cs
@@ -5,7 +5,7 @@
 
 namespace System.Security.Cryptography
 {
-    internal static class HashAlgorithmNames
+    internal static partial class HashAlgorithmNames
     {
         // These are accepted by CNG
         public const string MD5 = "MD5";
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.Apple.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.Apple.cs
index fa80816a75abfb..296cafef903597 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.Apple.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.Apple.cs
@@ -5,31 +5,22 @@
 using System.Security.Cryptography.Apple;
 using Internal.Cryptography;
 
+using PAL_HashAlgorithm = Interop.AppleCrypto.PAL_HashAlgorithm;
+
 namespace System.Security.Cryptography
 {
     internal static partial class HashProviderDispenser
     {
         public static HashProvider CreateHashProvider(string hashAlgorithmId)
         {
-            Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmToPal(hashAlgorithmId);
-            return new AppleDigestProvider(algorithm);
+            return new AppleDigestProvider(hashAlgorithmId);
         }
 
         public static HashProvider CreateMacProvider(string hashAlgorithmId, ReadOnlySpan<byte> key)
         {
-            Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmToPal(hashAlgorithmId);
-            return new AppleHmacProvider(algorithm, key);
+            return new AppleHmacProvider(hashAlgorithmId, key);
         }
 
-        private static Interop.AppleCrypto.PAL_HashAlgorithm HashAlgorithmToPal(string hashAlgorithmId) => hashAlgorithmId switch {
-            HashAlgorithmNames.MD5 => Interop.AppleCrypto.PAL_HashAlgorithm.Md5,
-            HashAlgorithmNames.SHA1 => Interop.AppleCrypto.PAL_HashAlgorithm.Sha1,
-            HashAlgorithmNames.SHA256 => Interop.AppleCrypto.PAL_HashAlgorithm.Sha256,
-            HashAlgorithmNames.SHA384 => Interop.AppleCrypto.PAL_HashAlgorithm.Sha384,
-            HashAlgorithmNames.SHA512 => Interop.AppleCrypto.PAL_HashAlgorithm.Sha512,
-            _ => throw new CryptographicException(SR.Format(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithmId))
-        };
-
         internal static class OneShotHashProvider
         {
             public static unsafe int MacData(
@@ -38,7 +29,7 @@ public static unsafe int MacData(
                 ReadOnlySpan<byte> source,
                 Span<byte> destination)
             {
-                Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmToPal(hashAlgorithmId);
+                Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmNames.HashAlgorithmToPal(hashAlgorithmId);
 
                 fixed (byte* pKey = key)
                 fixed (byte* pSource = source)
@@ -69,7 +60,7 @@ public static unsafe int MacData(
 
             public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> source, Span<byte> destination)
             {
-                Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmToPal(hashAlgorithmId);
+                Interop.AppleCrypto.PAL_HashAlgorithm algorithm = HashAlgorithmNames.HashAlgorithmToPal(hashAlgorithmId);
 
                 fixed (byte* pSource = source)
                 fixed (byte* pDestination = destination)
@@ -96,205 +87,117 @@ public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> sou
             }
         }
 
-        private sealed class AppleHmacProvider : HashProvider
+        private sealed class AppleDigestProvider : HashProvider
         {
-            private readonly byte[] _key;
-            private readonly SafeHmacHandle _ctx;
-
+            private readonly LiteHash _liteHash;
             private bool _running;
 
-            public override int HashSizeInBytes { get; }
-
-            internal AppleHmacProvider(Interop.AppleCrypto.PAL_HashAlgorithm algorithm, ReadOnlySpan<byte> key)
+            public AppleDigestProvider(string hashAlgorithmId)
             {
-                _key = key.ToArray();
-                int hashSizeInBytes = 0;
-                _ctx = Interop.AppleCrypto.HmacCreate(algorithm, ref hashSizeInBytes);
-
-                if (hashSizeInBytes < 0)
-                {
-                    _ctx.Dispose();
-                    throw new PlatformNotSupportedException(
-                        SR.Format(
-                            SR.Cryptography_UnknownHashAlgorithm,
-                            Enum.GetName(typeof(Interop.AppleCrypto.PAL_HashAlgorithm), algorithm)));
-                }
-
-                if (_ctx.IsInvalid)
-                {
-                    _ctx.Dispose();
-                    throw new CryptographicException();
-                }
-
-                HashSizeInBytes = hashSizeInBytes;
+                _liteHash = LiteHashProvider.CreateHash(hashAlgorithmId);
             }
 
             public override void AppendHashData(ReadOnlySpan<byte> data)
             {
-                if (!_running)
-                {
-                    SetKey();
-                }
-
-                if (Interop.AppleCrypto.HmacUpdate(_ctx, data) != 1)
-                {
-                    throw new CryptographicException();
-                }
-            }
-
-            private void SetKey()
-            {
-                if (Interop.AppleCrypto.HmacInit(_ctx, _key, _key.Length) != 1)
-                {
-                    throw new CryptographicException();
-                }
-
+                _liteHash.Append(data);
                 _running = true;
             }
 
-            public override unsafe int FinalizeHashAndReset(Span<byte> destination)
+            public override int FinalizeHashAndReset(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= HashSizeInBytes);
-
-                if (!_running)
-                {
-                    SetKey();
-                }
-
-                if (Interop.AppleCrypto.HmacFinal(_ctx, destination) != 1)
-                {
-                    throw new CryptographicException();
-                }
-
+                int written = _liteHash.Finalize(destination);
+                // Apple's DigestFinal self-resets, so don't bother calling reset.
                 _running = false;
-                return HashSizeInBytes;
+                return written;
             }
 
-            public override unsafe int GetCurrentHash(Span<byte> destination)
+            public override int GetCurrentHash(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= HashSizeInBytes);
+                return _liteHash.Current(destination);
+            }
 
-                if (!_running)
-                {
-                    SetKey();
-                }
+            public override int HashSizeInBytes => _liteHash.HashSizeInBytes;
 
-                if (Interop.AppleCrypto.HmacCurrent(_ctx, destination) != 1)
+            public override void Dispose(bool disposing)
+            {
+                if (disposing)
                 {
-                    throw new CryptographicException();
+                    _liteHash.Dispose();
                 }
-
-                return HashSizeInBytes;
             }
 
-            public override void Dispose(bool disposing)
+            public override void Reset()
             {
-                if (disposing)
+                if (_running)
                 {
-                    _ctx?.Dispose();
-                    Array.Clear(_key);
+                    _liteHash.Reset();
+                    _running = false;
                 }
             }
-
-            public override void Reset() => _running = false;
         }
 
-        private sealed class AppleDigestProvider : HashProvider
+        private sealed class AppleHmacProvider : HashProvider
         {
-            private readonly SafeDigestCtxHandle _ctx;
+            private readonly LiteHmac _liteHmac;
+            private readonly byte[] _key;
             private bool _running;
 
-            public override int HashSizeInBytes { get; }
-
-            internal AppleDigestProvider(Interop.AppleCrypto.PAL_HashAlgorithm algorithm)
+            public AppleHmacProvider(string hashAlgorithmId, ReadOnlySpan<byte> key)
             {
-                int hashSizeInBytes;
-                _ctx = Interop.AppleCrypto.DigestCreate(algorithm, out hashSizeInBytes);
-
-                if (hashSizeInBytes < 0)
-                {
-                    _ctx.Dispose();
-                    throw new PlatformNotSupportedException(
-                        SR.Format(
-                            SR.Cryptography_UnknownHashAlgorithm,
-                            Enum.GetName(typeof(Interop.AppleCrypto.PAL_HashAlgorithm), algorithm)));
-                }
-
-                if (_ctx.IsInvalid)
-                {
-                    _ctx.Dispose();
-                    throw new CryptographicException();
-                }
-
-                HashSizeInBytes = hashSizeInBytes;
+                PAL_HashAlgorithm algorithm = HashAlgorithmNames.HashAlgorithmToPal(hashAlgorithmId);
+                _liteHmac = new LiteHmac(algorithm, key, preinitialize: false);
+                _key = key.ToArray();
             }
 
             public override void AppendHashData(ReadOnlySpan<byte> data)
             {
-                _running = true;
-                int ret = Interop.AppleCrypto.DigestUpdate(_ctx, data);
-
-                if (ret != 1)
+                if (!_running)
                 {
-                    Debug.Assert(ret == 0, $"DigestUpdate return value {ret} was not 0 or 1");
-                    throw new CryptographicException();
+                    _liteHmac.Reset(_key);
                 }
+
+                _liteHmac.Append(data);
+                _running = true;
             }
 
             public override int FinalizeHashAndReset(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= HashSizeInBytes);
-
-                int ret = Interop.AppleCrypto.DigestFinal(_ctx, destination);
-                _running = false;
-
-                if (ret != 1)
+                if (!_running)
                 {
-                    Debug.Assert(ret == 0, $"DigestFinal return value {ret} was not 0 or 1");
-                    throw new CryptographicException();
+                    _liteHmac.Reset(_key);
                 }
 
-                return HashSizeInBytes;
+                int written = _liteHmac.Finalize(destination);
+                _liteHmac.Reset(_key);
+                _running = false;
+                return written;
             }
 
             public override int GetCurrentHash(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= HashSizeInBytes);
-
-                int ret = Interop.AppleCrypto.DigestCurrent(_ctx, destination);
-
-                if (ret != 1)
+                if (!_running)
                 {
-                    Debug.Assert(ret == 0, $"DigestFinal return value {ret} was not 0 or 1");
-                    throw new CryptographicException();
+                    _liteHmac.Reset(_key);
                 }
 
-                return HashSizeInBytes;
+                return _liteHmac.Current(destination);
             }
 
-            public override void Reset()
-            {
-                if (_running)
-                {
-                    int ret = Interop.AppleCrypto.DigestReset(_ctx);
-
-                    if (ret != 1)
-                    {
-                        Debug.Assert(ret == 0, $"DigestReset return value {ret} was not 0 or 1");
-                        throw new CryptographicException();
-                    }
-
-                    _running = false;
-                }
-            }
+            public override int HashSizeInBytes => _liteHmac.HashSizeInBytes;
 
             public override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    _ctx?.Dispose();
+                    _liteHmac.Dispose();
+                    Array.Clear(_key);
                 }
             }
+
+            public override void Reset()
+            {
+                _running = false;
+            }
         }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.OpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.OpenSsl.cs
index db75677b66ae8f..32cdc7dd93b1cc 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.OpenSsl.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HashProviderDispenser.OpenSsl.cs
@@ -14,14 +14,12 @@ internal static partial class HashProviderDispenser
     {
         internal static HashProvider CreateHashProvider(string hashAlgorithmId)
         {
-            IntPtr evpType = Interop.Crypto.HashAlgorithmToEvp(hashAlgorithmId);
-            return new EvpHashProvider(evpType);
+            return new EvpHashProvider(hashAlgorithmId);
         }
 
         internal static HashProvider CreateMacProvider(string hashAlgorithmId, ReadOnlySpan<byte> key)
         {
-            IntPtr evpType = Interop.Crypto.HashAlgorithmToEvp(hashAlgorithmId);
-            return new HmacHashProvider(evpType, key);
+            return new HmacHashProvider(hashAlgorithmId, key);
         }
 
         internal static class OneShotHashProvider
@@ -61,8 +59,16 @@ public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> sou
                 fixed (byte* pSource = source)
                 fixed (byte* pDestination = destination)
                 {
+                    const int Success = 1;
                     uint length = (uint)destination.Length;
-                    Check(Interop.Crypto.EvpDigestOneShot(evpType, pSource, source.Length, pDestination, &length));
+                    int ret = Interop.Crypto.EvpDigestOneShot(evpType, pSource, source.Length, pDestination, &length);
+
+                    if (ret != Success)
+                    {
+                        Debug.Assert(ret == 0);
+                        throw Interop.Crypto.CreateOpenSslCryptographicException();
+                    }
+
                     Debug.Assert(length == hashSize);
                 }
 
@@ -72,71 +78,40 @@ public static unsafe int HashData(string hashAlgorithmId, ReadOnlySpan<byte> sou
 
         private sealed class EvpHashProvider : HashProvider
         {
-            private readonly IntPtr _algorithmEvp;
-            private readonly int _hashSize;
-            private readonly SafeEvpMdCtxHandle _ctx;
+            private readonly LiteHash _liteHash;
             private bool _running;
 
-            public EvpHashProvider(IntPtr algorithmEvp)
+            public EvpHashProvider(string hashAlgorithmId)
             {
-                _algorithmEvp = algorithmEvp;
-                Debug.Assert(algorithmEvp != IntPtr.Zero);
-
-                _hashSize = Interop.Crypto.EvpMdSize(_algorithmEvp);
-                if (_hashSize <= 0 || _hashSize > Interop.Crypto.EVP_MAX_MD_SIZE)
-                {
-                    throw new CryptographicException();
-                }
-
-                _ctx = Interop.Crypto.EvpMdCtxCreate(_algorithmEvp);
-
-                Interop.Crypto.CheckValidOpenSslHandle(_ctx);
+                _liteHash = LiteHashProvider.CreateHash(hashAlgorithmId);
             }
 
             public override void AppendHashData(ReadOnlySpan<byte> data)
             {
-                if (data.IsEmpty)
-                {
-                    return;
-                }
-
+                _liteHash.Append(data);
                 _running = true;
-                Check(Interop.Crypto.EvpDigestUpdate(_ctx, data, data.Length));
             }
 
             public override int FinalizeHashAndReset(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= _hashSize);
-
-                uint length = (uint)destination.Length;
-                Check(Interop.Crypto.EvpDigestFinalEx(_ctx, ref MemoryMarshal.GetReference(destination), ref length));
-                Debug.Assert(length == _hashSize);
-
-                // Reset the algorithm provider.
-                Check(Interop.Crypto.EvpDigestReset(_ctx, _algorithmEvp));
+                int written = _liteHash.Finalize(destination);
+                _liteHash.Reset();
                 _running = false;
-
-                return _hashSize;
+                return written;
             }
 
             public override int GetCurrentHash(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= _hashSize);
-
-                uint length = (uint)destination.Length;
-                Check(Interop.Crypto.EvpDigestCurrent(_ctx, ref MemoryMarshal.GetReference(destination), ref length));
-                Debug.Assert(length == _hashSize);
-
-                return _hashSize;
+                return _liteHash.Current(destination);
             }
 
-            public override int HashSizeInBytes => _hashSize;
+            public override int HashSizeInBytes => _liteHash.HashSizeInBytes;
 
             public override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    _ctx.Dispose();
+                    _liteHash.Dispose();
                 }
             }
 
@@ -144,7 +119,7 @@ public override void Reset()
             {
                 if (_running)
                 {
-                    Check(Interop.Crypto.EvpDigestReset(_ctx, _algorithmEvp));
+                    _liteHash.Reset();
                     _running = false;
                 }
             }
@@ -152,67 +127,40 @@ public override void Reset()
 
         private sealed class HmacHashProvider : HashProvider
         {
-            private readonly int _hashSize;
-            private SafeHmacCtxHandle _hmacCtx;
+            private readonly LiteHmac _liteHmac;
             private bool _running;
 
-            public HmacHashProvider(IntPtr algorithmEvp, ReadOnlySpan<byte> key)
+            public HmacHashProvider(string hashAlgorithmId, ReadOnlySpan<byte> key)
             {
-                Debug.Assert(algorithmEvp != IntPtr.Zero);
-
-                _hashSize = Interop.Crypto.EvpMdSize(algorithmEvp);
-                if (_hashSize <= 0 || _hashSize > Interop.Crypto.EVP_MAX_MD_SIZE)
-                {
-                    throw new CryptographicException();
-                }
-
-                _hmacCtx = Interop.Crypto.HmacCreate(ref MemoryMarshal.GetReference(key), key.Length, algorithmEvp);
-                Interop.Crypto.CheckValidOpenSslHandle(_hmacCtx);
+                _liteHmac = LiteHashProvider.CreateHmac(hashAlgorithmId, key);
             }
 
             public override void AppendHashData(ReadOnlySpan<byte> data)
             {
-                if (data.IsEmpty)
-                {
-                    return;
-                }
-
+                _liteHmac.Append(data);
                 _running = true;
-                Check(Interop.Crypto.HmacUpdate(_hmacCtx, data, data.Length));
             }
 
             public override int FinalizeHashAndReset(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= _hashSize);
-
-                int length = destination.Length;
-                Check(Interop.Crypto.HmacFinal(_hmacCtx, ref MemoryMarshal.GetReference(destination), ref length));
-                Debug.Assert(length == _hashSize);
-
-                Check(Interop.Crypto.HmacReset(_hmacCtx));
+                int written = _liteHmac.Finalize(destination);
+                _liteHmac.Reset();
                 _running = false;
-                return _hashSize;
+                return written;
             }
 
             public override int GetCurrentHash(Span<byte> destination)
             {
-                Debug.Assert(destination.Length >= _hashSize);
-
-                int length = destination.Length;
-                Check(Interop.Crypto.HmacCurrent(_hmacCtx, ref MemoryMarshal.GetReference(destination), ref length));
-                Debug.Assert(length == _hashSize);
-
-                return _hashSize;
+                return _liteHmac.Current(destination);
             }
 
-            public override int HashSizeInBytes => _hashSize;
+            public override int HashSizeInBytes => _liteHmac.HashSizeInBytes;
 
             public override void Dispose(bool disposing)
             {
-                if (disposing && _hmacCtx != null)
+                if (disposing)
                 {
-                    _hmacCtx.Dispose();
-                    _hmacCtx = null!;
+                    _liteHmac.Dispose();
                 }
             }
 
@@ -220,20 +168,10 @@ public override void Reset()
             {
                 if (_running)
                 {
-                    Check(Interop.Crypto.HmacReset(_hmacCtx));
+                    _liteHmac.Reset();
                     _running = false;
                 }
             }
         }
-
-        private static void Check(int result)
-        {
-            const int Success = 1;
-            if (result != Success)
-            {
-                Debug.Assert(result == 0);
-                throw Interop.Crypto.CreateOpenSslCryptographicException();
-            }
-        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs
new file mode 100644
index 00000000000000..d00b61334320c7
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs
@@ -0,0 +1,215 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Security.Cryptography.Apple;
+
+using PAL_HashAlgorithm = Interop.AppleCrypto.PAL_HashAlgorithm;
+
+namespace System.Security.Cryptography
+{
+    internal static partial class LiteHashProvider
+    {
+        internal static LiteHash CreateHash(string hashAlgorithmId)
+        {
+            PAL_HashAlgorithm algorithm = HashAlgorithmNames.HashAlgorithmToPal(hashAlgorithmId);
+            return new LiteHash(algorithm);
+        }
+
+        internal static LiteHmac CreateHmac(string hashAlgorithmId, ReadOnlySpan<byte> key)
+        {
+            PAL_HashAlgorithm algorithm = HashAlgorithmNames.HashAlgorithmToPal(hashAlgorithmId);
+            return new LiteHmac(algorithm, key, preinitialize: true);
+        }
+    }
+
+    internal readonly struct LiteHash : ILiteHash
+    {
+        private readonly SafeDigestCtxHandle _ctx;
+        private readonly int _hashSizeInBytes;
+
+        private const int Success = 1;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHash(PAL_HashAlgorithm algorithm)
+        {
+            int hashSizeInBytes;
+            _ctx = Interop.AppleCrypto.DigestCreate(algorithm, out hashSizeInBytes);
+
+            if (hashSizeInBytes < 0)
+            {
+                _ctx.Dispose();
+                throw new PlatformNotSupportedException(
+                    SR.Format(
+                        SR.Cryptography_UnknownHashAlgorithm,
+                        Enum.GetName(typeof(PAL_HashAlgorithm), algorithm)));
+            }
+
+            if (_ctx.IsInvalid)
+            {
+                _ctx.Dispose();
+                throw new CryptographicException();
+            }
+
+            _hashSizeInBytes = hashSizeInBytes;
+        }
+
+        public void Append(ReadOnlySpan<byte> data)
+        {
+            if (data.IsEmpty)
+            {
+                return;
+            }
+
+            int ret = Interop.AppleCrypto.DigestUpdate(_ctx, data);
+
+            if (ret != Success)
+            {
+                Debug.Assert(ret == 0, $"{nameof(Interop.AppleCrypto.DigestUpdate)} return value {ret} was not 0 or 1");
+                throw new CryptographicException();
+            }
+        }
+
+        public int Current(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            int ret = Interop.AppleCrypto.DigestCurrent(_ctx, destination);
+
+            if (ret != Success)
+            {
+                Debug.Assert(ret == 0, $"{nameof(Interop.AppleCrypto.DigestCurrent)} return value {ret} was not 0 or 1");
+                throw new CryptographicException();
+            }
+
+            return _hashSizeInBytes;
+        }
+
+        public int Finalize(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            int ret = Interop.AppleCrypto.DigestFinal(_ctx, destination);
+
+            if (ret != Success)
+            {
+                Debug.Assert(ret == 0, $"{nameof(Interop.AppleCrypto.DigestFinal)} return value {ret} was not 0 or 1");
+                throw new CryptographicException();
+            }
+
+            return _hashSizeInBytes;
+        }
+
+        public void Reset()
+        {
+            int ret = Interop.AppleCrypto.DigestReset(_ctx);
+
+            if (ret != Success)
+            {
+                Debug.Assert(ret == 0, $"DigestReset return value {ret} was not 0 or 1");
+                throw new CryptographicException();
+            }
+        }
+
+        public void Dispose()
+        {
+            _ctx.Dispose();
+        }
+    }
+
+    internal readonly struct LiteHmac : ILiteHash
+    {
+        private readonly SafeHmacHandle _ctx;
+        private readonly int _hashSizeInBytes;
+
+        private const int Success = 1;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHmac(PAL_HashAlgorithm algorithm, ReadOnlySpan<byte> key, bool preinitialize)
+        {
+            int hashSizeInBytes = 0;
+            _ctx = Interop.AppleCrypto.HmacCreate(algorithm, ref hashSizeInBytes);
+
+            if (hashSizeInBytes < 0)
+            {
+                _ctx.Dispose();
+                throw new PlatformNotSupportedException(
+                    SR.Format(
+                        SR.Cryptography_UnknownHashAlgorithm,
+                        Enum.GetName(typeof(Interop.AppleCrypto.PAL_HashAlgorithm), algorithm)));
+            }
+
+            if (_ctx.IsInvalid)
+            {
+                _ctx.Dispose();
+                throw new CryptographicException();
+            }
+
+            if (preinitialize)
+            {
+                if (Interop.AppleCrypto.HmacInit(_ctx, key) != Success)
+                {
+                    _ctx.Dispose();
+                    throw new CryptographicException();
+                }
+            }
+
+            _hashSizeInBytes = hashSizeInBytes;
+        }
+
+        public void Append(ReadOnlySpan<byte> data)
+        {
+            if (data.IsEmpty)
+            {
+                return;
+            }
+
+            if (Interop.AppleCrypto.HmacUpdate(_ctx, data) != Success)
+            {
+                Debug.Fail($"{nameof(Interop.AppleCrypto.HmacUpdate)} unexpectedly failed.");
+                throw new CryptographicException();
+            }
+        }
+
+        public int Current(ReadOnlySpan<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            if (Interop.AppleCrypto.HmacCurrent(_ctx, destination) != Success)
+            {
+                Debug.Fail($"{nameof(Interop.AppleCrypto.HmacCurrent)} unexpectedly failed.");
+                throw new CryptographicException();
+            }
+
+            return _hashSizeInBytes;
+        }
+
+        public int Finalize(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            if (Interop.AppleCrypto.HmacFinal(_ctx, destination) != Success)
+            {
+                Debug.Fail($"{nameof(Interop.AppleCrypto.HmacFinal)} unexpectedly failed.");
+                throw new CryptographicException();
+            }
+
+            return _hashSizeInBytes;
+        }
+
+        public void Reset(ReadOnlySpan<byte> key)
+        {
+            if (Interop.AppleCrypto.HmacInit(_ctx, key) != Success)
+            {
+                Debug.Fail($"{nameof(Interop.AppleCrypto.HmacInit)} unexpectedly failed.");
+            }
+        }
+
+        public void Dispose()
+        {
+            _ctx.Dispose();
+        }
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs
new file mode 100644
index 00000000000000..706427758605c6
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs
@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using Internal.Cryptography;
+
+namespace System.Security.Cryptography
+{
+    internal static partial class LiteHashProvider
+    {
+        private static LiteHash CreateHash(string hashAlgorithmId)
+        {
+            return new LiteHash(hashAlgorithmId);
+        }
+
+        private static LiteHmac CreateHmac(string hashAlgorithmId, ReadOnlySpan<byte> key)
+        {
+            return new LiteHmac(hashAlgorithmId, key);
+        }
+    }
+
+    internal readonly struct LiteHash : ILiteHash
+    {
+        private readonly HashProvider _provider;
+        private readonly int _hashSizeInBytes;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHash(string hashAlgorithmId)
+        {
+            _provider = HashProviderDispenser.CreateHashProvider(hashAlgorithmId);
+            _hashSizeInBytes = _provider.HashSizeInBytes;
+        }
+
+        public void Append(ReadOnlySpan<byte> data) => _provider.AppendHashData(data);
+        public int Finalize(Span<byte> destination) => _provider.FinalizeHashAndReset(destination);
+        public void Dispose() => _provider.Dispose();
+    }
+
+    internal readonly struct LiteHmac : ILiteHash
+    {
+        private readonly HashProvider _provider;
+        private readonly int _hashSizeInBytes;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHmac(string hashAlgorithmId, ReadOnlySpan<byte> key)
+        {
+            _provider = HashProviderDispenser.CreateMacProvider(hashAlgorithmId, key);
+            _hashSizeInBytes = _provider.HashSizeInBytes;
+        }
+
+        public void Append(ReadOnlySpan<byte> data) => _provider.AppendHashData(data);
+        public int Finalize(Span<byte> destination) => _provider.FinalizeHashAndReset(destination);
+        public void Dispose() => _provider.Dispose();
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs
new file mode 100644
index 00000000000000..05b55230e14b70
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs
@@ -0,0 +1,174 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Win32.SafeHandles;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace System.Security.Cryptography
+{
+    internal static partial class LiteHashProvider
+    {
+        internal static LiteHash CreateHash(string hashAlgorithmId)
+        {
+            IntPtr algorithm = Interop.Crypto.HashAlgorithmToEvp(hashAlgorithmId);
+            return new LiteHash(algorithm);
+        }
+
+        internal static LiteHmac CreateHmac(string hashAlgorithmId, ReadOnlySpan<byte> key)
+        {
+            IntPtr algorithm = Interop.Crypto.HashAlgorithmToEvp(hashAlgorithmId);
+            return new LiteHmac(algorithm, key);
+        }
+    }
+
+    internal readonly struct LiteHash : ILiteHash
+    {
+        private readonly SafeEvpMdCtxHandle _ctx;
+        private readonly IntPtr _algorithm;
+        private readonly int _hashSizeInBytes;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHash(IntPtr algorithm)
+        {
+            Debug.Assert(algorithm != IntPtr.Zero);
+
+            _algorithm = algorithm;
+            _hashSizeInBytes = Interop.Crypto.EvpMdSize(algorithm);
+
+            if (_hashSizeInBytes <= 0 || _hashSizeInBytes > Interop.Crypto.EVP_MAX_MD_SIZE)
+            {
+                Debug.Fail($"Unexpected hash '{_hashSizeInBytes}' size from {nameof(Interop.Crypto.EvpMdSize)}.");
+                throw new CryptographicException();
+            }
+
+            _ctx = Interop.Crypto.EvpMdCtxCreate(algorithm);
+            Interop.Crypto.CheckValidOpenSslHandle(_ctx);
+        }
+
+        public void Append(ReadOnlySpan<byte> data)
+        {
+            if (data.IsEmpty)
+            {
+                return;
+            }
+
+            Check(Interop.Crypto.EvpDigestUpdate(_ctx, data, data.Length));
+        }
+
+        public int Finalize(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            uint length = (uint)destination.Length;
+            Check(Interop.Crypto.EvpDigestFinalEx(_ctx, ref MemoryMarshal.GetReference(destination), ref length));
+
+            Debug.Assert(length == _hashSizeInBytes);
+            return _hashSizeInBytes;
+        }
+
+        public void Reset()
+        {
+            Check(Interop.Crypto.EvpDigestReset(_ctx, _algorithm));
+        }
+
+        public int Current(Span<byte> destination)
+        {
+            uint length = (uint)destination.Length;
+            Check(Interop.Crypto.EvpDigestCurrent(_ctx, ref MemoryMarshal.GetReference(destination), ref length));
+            Debug.Assert(length == _hashSizeInBytes);
+            return _hashSizeInBytes;
+        }
+
+        public void Dispose()
+        {
+            _ctx.Dispose();
+        }
+
+        private static void Check(int result)
+        {
+            const int Success = 1;
+
+            if (result != Success)
+            {
+                Debug.Assert(result == 0);
+                throw Interop.Crypto.CreateOpenSslCryptographicException();
+            }
+        }
+    }
+
+    internal readonly struct LiteHmac : ILiteHash
+    {
+        private readonly SafeHmacCtxHandle _ctx;
+        private readonly int _hashSizeInBytes;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHmac(IntPtr algorithm, ReadOnlySpan<byte> key)
+        {
+            Debug.Assert(algorithm != IntPtr.Zero);
+            _hashSizeInBytes = Interop.Crypto.EvpMdSize(algorithm);
+
+            if (_hashSizeInBytes <= 0 || _hashSizeInBytes > Interop.Crypto.EVP_MAX_MD_SIZE)
+            {
+                Debug.Fail($"Unexpected hash '{_hashSizeInBytes}' size from {nameof(Interop.Crypto.EvpMdSize)}.");
+                throw new CryptographicException();
+            }
+
+            _ctx = Interop.Crypto.HmacCreate(ref MemoryMarshal.GetReference(key), key.Length, algorithm);
+            Interop.Crypto.CheckValidOpenSslHandle(_ctx);
+        }
+
+        public void Append(ReadOnlySpan<byte> data)
+        {
+            if (data.IsEmpty)
+            {
+                return;
+            }
+
+            Check(Interop.Crypto.HmacUpdate(_ctx, data, data.Length));
+        }
+
+        public int Current(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            int length = destination.Length;
+            Check(Interop.Crypto.HmacCurrent(_ctx, ref MemoryMarshal.GetReference(destination), ref length));
+            Debug.Assert(length == _hashSizeInBytes);
+            return _hashSizeInBytes;
+        }
+
+        public int Finalize(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            int length = destination.Length;
+            Check(Interop.Crypto.HmacFinal(_ctx, ref MemoryMarshal.GetReference(destination), ref length));
+            Debug.Assert(length == _hashSizeInBytes);
+            return _hashSizeInBytes;
+        }
+
+        public void Reset()
+        {
+            Check(Interop.Crypto.HmacReset(_ctx));
+        }
+
+        public void Dispose()
+        {
+            _ctx.Dispose();
+        }
+
+        private static void Check(int result)
+        {
+            const int Success = 1;
+
+            if (result != Success)
+            {
+                Debug.Assert(result == 0);
+                throw Interop.Crypto.CreateOpenSslCryptographicException();
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs
new file mode 100644
index 00000000000000..0fa10b16cbabb7
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs
@@ -0,0 +1,173 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Win32.SafeHandles;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+using BCryptCreateHashFlags = Interop.BCrypt.BCryptCreateHashFlags;
+using BCryptOpenAlgorithmProviderFlags = Interop.BCrypt.BCryptOpenAlgorithmProviderFlags;
+using NTSTATUS = Interop.BCrypt.NTSTATUS;
+
+namespace System.Security.Cryptography
+{
+    internal static partial class LiteHashProvider
+    {
+        private static LiteHash CreateHash(string hashAlgorithmId)
+        {
+            return new LiteHash(hashAlgorithmId);
+        }
+
+        private static LiteHmac CreateHmac(string hashAlgorithmId, ReadOnlySpan<byte> key)
+        {
+            return new LiteHmac(hashAlgorithmId, key);
+        }
+    }
+
+    internal readonly struct LiteHash : ILiteHash
+    {
+        private readonly SafeBCryptHashHandle _hashHandle;
+        private readonly int _hashSizeInBytes;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHash(string algorithm)
+        {
+
+            BCryptOpenAlgorithmProviderFlags algorithmFlags =
+                BCryptOpenAlgorithmProviderFlags.None;
+
+            // This is a shared handle, do not put this in a using.
+            SafeBCryptAlgorithmHandle algorithmHandle = Interop.BCrypt.BCryptAlgorithmCache.GetCachedBCryptAlgorithmHandle(
+                algorithm,
+                algorithmFlags,
+                out _hashSizeInBytes);
+
+            SafeBCryptHashHandle hashHandle;
+
+            NTSTATUS ntStatus = Interop.BCrypt.BCryptCreateHash(
+                algorithmHandle,
+                out hashHandle,
+                pbHashObject: IntPtr.Zero,
+                cbHashObject: 0,
+                secret: ReadOnlySpan<byte>.Empty,
+                cbSecret: 0,
+                BCryptCreateHashFlags.None);
+
+            if (ntStatus != NTSTATUS.STATUS_SUCCESS)
+            {
+                hashHandle.Dispose();
+                throw Interop.BCrypt.CreateCryptographicException(ntStatus);
+            }
+
+            _hashHandle = hashHandle;
+        }
+
+        public void Append(ReadOnlySpan<byte> data)
+        {
+            if (data.IsEmpty)
+            {
+                return;
+            }
+
+            NTSTATUS ntStatus = Interop.BCrypt.BCryptHashData(_hashHandle, data, data.Length, dwFlags: 0);
+
+            if (ntStatus != NTSTATUS.STATUS_SUCCESS)
+            {
+                throw Interop.BCrypt.CreateCryptographicException(ntStatus);
+            }
+        }
+
+        public int Finalize(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            NTSTATUS ntStatus = Interop.BCrypt.BCryptFinishHash(_hashHandle, destination, _hashSizeInBytes, dwFlags: 0);
+
+            if (ntStatus != NTSTATUS.STATUS_SUCCESS)
+            {
+                throw Interop.BCrypt.CreateCryptographicException(ntStatus);
+            }
+
+            return _hashSizeInBytes;
+        }
+
+        public void Dispose()
+        {
+            _hashHandle.Dispose();
+        }
+    }
+
+    internal readonly struct LiteHmac : ILiteHash
+    {
+        private readonly SafeBCryptHashHandle _hashHandle;
+        private readonly int _hashSizeInBytes;
+
+        public int HashSizeInBytes => _hashSizeInBytes;
+
+        internal LiteHmac(string algorithm, ReadOnlySpan<byte> key)
+        {
+            BCryptOpenAlgorithmProviderFlags algorithmFlags =
+                BCryptOpenAlgorithmProviderFlags.BCRYPT_ALG_HANDLE_HMAC_FLAG;
+
+            // This is a shared handle, do not put this in a using.
+            SafeBCryptAlgorithmHandle algorithmHandle = Interop.BCrypt.BCryptAlgorithmCache.GetCachedBCryptAlgorithmHandle(
+                algorithm,
+                algorithmFlags,
+                out _hashSizeInBytes);
+
+            SafeBCryptHashHandle hashHandle;
+
+            NTSTATUS ntStatus = Interop.BCrypt.BCryptCreateHash(
+                algorithmHandle,
+                out hashHandle,
+                pbHashObject: IntPtr.Zero,
+                cbHashObject: 0,
+                key,
+                key.Length,
+                BCryptCreateHashFlags.None);
+
+            if (ntStatus != NTSTATUS.STATUS_SUCCESS)
+            {
+                hashHandle.Dispose();
+                throw Interop.BCrypt.CreateCryptographicException(ntStatus);
+            }
+
+            _hashHandle = hashHandle;
+        }
+
+        public void Append(ReadOnlySpan<byte> data)
+        {
+            if (data.IsEmpty)
+            {
+                return;
+            }
+
+            NTSTATUS ntStatus = Interop.BCrypt.BCryptHashData(_hashHandle, data, data.Length, dwFlags: 0);
+
+            if (ntStatus != NTSTATUS.STATUS_SUCCESS)
+            {
+                throw Interop.BCrypt.CreateCryptographicException(ntStatus);
+            }
+        }
+
+        public int Finalize(Span<byte> destination)
+        {
+            Debug.Assert(destination.Length >= _hashSizeInBytes);
+
+            NTSTATUS ntStatus = Interop.BCrypt.BCryptFinishHash(_hashHandle, destination, _hashSizeInBytes, dwFlags: 0);
+
+            if (ntStatus != NTSTATUS.STATUS_SUCCESS)
+            {
+                throw Interop.BCrypt.CreateCryptographicException(ntStatus);
+            }
+
+            return _hashSizeInBytes;
+        }
+
+        public void Dispose()
+        {
+            _hashHandle.Dispose();
+        }
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHashProvider.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHashProvider.cs
new file mode 100644
index 00000000000000..82aceb127fb625
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHashProvider.cs
@@ -0,0 +1,195 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Security.Cryptography
+{
+    internal static partial class LiteHashProvider
+    {
+        internal static int HashStream(string hashAlgorithmId, int hashSizeInBytes, Stream source, Span<byte> destination)
+        {
+            LiteHash hash = CreateHash(hashAlgorithmId);
+            return ProcessStream(hash, source, destination);
+        }
+
+        internal static byte[] HashStream(string hashAlgorithmId, int hashSizeInBytes, Stream source)
+        {
+            byte[] result = new byte[hashSizeInBytes];
+            LiteHash hash = CreateHash(hashAlgorithmId);
+            int written = ProcessStream(hash, source, result);
+            Debug.Assert(written == hashSizeInBytes);
+            return result;
+        }
+
+        internal static ValueTask<int> HashStreamAsync(
+            string hashAlgorithmId,
+            int hashSizeInBytes,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<int>(cancellationToken);
+            }
+
+            LiteHash hash = CreateHash(hashAlgorithmId);
+            return ProcessStreamAsync(hash, source, destination, cancellationToken);
+        }
+
+        internal static ValueTask<byte[]> HashStreamAsync(
+            string hashAlgorithmId,
+            int hashSizeInBytes,
+            Stream source,
+            CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<byte[]>(cancellationToken);
+            }
+
+            LiteHash hash = CreateHash(hashAlgorithmId);
+            return ProcessStreamAsync(hash, source, cancellationToken);
+        }
+
+        internal static int HmacStream(
+            string hashAlgorithmId,
+            int hashSizeInBytes,
+            ReadOnlySpan<byte> key,
+            Stream source,
+            Span<byte> destination)
+        {
+            LiteHmac hash = CreateHmac(hashAlgorithmId, key);
+            return ProcessStream(hash, source, destination);
+        }
+
+        internal static byte[] HmacStream(
+            string hashAlgorithmId,
+            int hashSizeInBytes,
+            ReadOnlySpan<byte> key,
+            Stream source)
+        {
+            byte[] result = new byte[hashSizeInBytes];
+            LiteHmac hash = CreateHmac(hashAlgorithmId, key);
+            int written = ProcessStream(hash, source, result);
+            Debug.Assert(written == hashSizeInBytes);
+            return result;
+        }
+
+        internal static ValueTask<int> HmacStreamAsync(
+            string hashAlgorithmId,
+            int hashSizeInBytes,
+            ReadOnlySpan<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<int>(cancellationToken);
+            }
+
+            LiteHmac hash = CreateHmac(hashAlgorithmId, key);
+            return ProcessStreamAsync(hash, source, destination, cancellationToken);
+        }
+
+        internal static ValueTask<byte[]> HmacStreamAsync(
+            string hashAlgorithmId,
+            int hashSizeInBytes,
+            ReadOnlySpan<byte> key,
+            Stream source,
+            CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled<byte[]>(cancellationToken);
+            }
+
+            LiteHmac hash = CreateHmac(hashAlgorithmId, key);
+            return ProcessStreamAsync(hash, source, cancellationToken);
+        }
+
+        /// This takes ownership of the hash parameter and disposes of it when done.
+        private static int ProcessStream<T>(T hash, Stream source, Span<byte> destination) where T : ILiteHash
+        {
+            using (hash)
+            {
+                byte[] rented = CryptoPool.Rent(4096);
+
+                int maxRead = 0;
+                int read;
+
+                try
+                {
+                    while ((read = source.Read(rented)) > 0)
+                    {
+                        maxRead = Math.Max(maxRead, read);
+                        hash.Append(rented.AsSpan(0, read));
+                    }
+
+                    return hash.Finalize(destination);
+                }
+                finally
+                {
+                    CryptoPool.Return(rented, clearSize: maxRead);
+                }
+            }
+        }
+
+        /// This takes ownership of the hash parameter and disposes of it when done.
+        private static async ValueTask<int> ProcessStreamAsync<T>(
+            T hash,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken) where T : ILiteHash
+        {
+            using (hash)
+            {
+                byte[] rented = CryptoPool.Rent(4096);
+
+                int maxRead = 0;
+                int read;
+
+                try
+                {
+                    while ((read = await source.ReadAsync(rented, cancellationToken).ConfigureAwait(false)) > 0)
+                    {
+                        maxRead = Math.Max(maxRead, read);
+                        hash.Append(rented.AsSpan(0, read));
+                    }
+
+                    return hash.Finalize(destination.Span);
+                }
+                finally
+                {
+                    CryptoPool.Return(rented, clearSize: maxRead);
+                }
+            }
+        }
+
+        /// This takes ownership of the hash parameter and disposes of it when done.
+        private static async ValueTask<byte[]> ProcessStreamAsync<T>(
+            T hash,
+            Stream source,
+            CancellationToken cancellationToken) where T : ILiteHash
+        {
+            byte[] result = new byte[hash.HashSizeInBytes];
+            int written = await ProcessStreamAsync(hash, source, result, cancellationToken).ConfigureAwait(false);
+
+            Debug.Assert(written == result.Length);
+            return result;
+        }
+    }
+
+    internal interface ILiteHash : IDisposable
+    {
+        int HashSizeInBytes { get; }
+
+        void Append(ReadOnlySpan<byte> data);
+        int Finalize(Span<byte> destination);
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MD5.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MD5.cs
index ce70b333089bcf..c1ba826d593559 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MD5.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MD5.cs
@@ -3,7 +3,10 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.IO;
 using System.Runtime.Versioning;
+using System.Threading;
+using System.Threading.Tasks;
 using Internal.Cryptography;
 
 namespace System.Security.Cryptography
@@ -112,6 +115,128 @@ public static bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination
             return true;
         }
 
+        /// <summary>
+        /// Computes the hash of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The MD5 algorithm always produces a 128-bit hash, or 16 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.MD5, HashSizeInBytes, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the hash of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.MD5, HashSizeInBytes, source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(HashAlgorithmNames.MD5, HashSizeInBytes, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the MD5 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The MD5 algorithm always produces a 128-bit hash, or 16 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(
+                HashAlgorithmNames.MD5,
+                HashSizeInBytes,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         private sealed class Implementation : MD5
         {
             private readonly HashProvider _hashProvider;
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA1.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA1.cs
index 0a66bc18b2854b..684d69e9a228c4 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA1.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA1.cs
@@ -4,6 +4,9 @@
 using Internal.Cryptography;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace System.Security.Cryptography
 {
@@ -111,6 +114,128 @@ public static bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination
             return true;
         }
 
+        /// <summary>
+        /// Computes the hash of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA1 algorithm always produces a 160-bit hash, or 20 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA1, HashSizeInBytes, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the hash of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA1, HashSizeInBytes, source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(HashAlgorithmNames.SHA1, HashSizeInBytes, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA1 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA1 algorithm always produces a 160-bit hash, or 20 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(
+                HashAlgorithmNames.SHA1,
+                HashSizeInBytes,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         private sealed class Implementation : SHA1
         {
             private readonly HashProvider _hashProvider;
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA256.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA256.cs
index da16eb86064301..fb48e9ffe00319 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA256.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA256.cs
@@ -4,6 +4,9 @@
 using Internal.Cryptography;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace System.Security.Cryptography
 {
@@ -111,6 +114,128 @@ public static bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination
             return true;
         }
 
+        /// <summary>
+        /// Computes the hash of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA256 algorithm always produces a 256-bit hash, or 32 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA256, HashSizeInBytes, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the hash of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA256, HashSizeInBytes, source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(HashAlgorithmNames.SHA256, HashSizeInBytes, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA256 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA256 algorithm always produces a 256-bit hash, or 32 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(
+                HashAlgorithmNames.SHA256,
+                HashSizeInBytes,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         private sealed class Implementation : SHA256
         {
             private readonly HashProvider _hashProvider;
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA384.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA384.cs
index 1ed1b72c04f615..89ba9d5c78b85c 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA384.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA384.cs
@@ -4,6 +4,9 @@
 using Internal.Cryptography;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace System.Security.Cryptography
 {
@@ -110,6 +113,128 @@ public static bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination
             return true;
         }
 
+        /// <summary>
+        /// Computes the hash of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA384 algorithm always produces a 384-bit hash, or 48 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA384, HashSizeInBytes, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the hash of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA384, HashSizeInBytes, source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(HashAlgorithmNames.SHA384, HashSizeInBytes, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA384 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA384 algorithm always produces a 384-bit hash, or 48 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(
+                HashAlgorithmNames.SHA384,
+                HashSizeInBytes,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         private sealed class Implementation : SHA384
         {
             private readonly HashProvider _hashProvider;
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA512.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA512.cs
index 5c6e52ab9cd9a2..924af115013d97 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA512.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SHA512.cs
@@ -4,6 +4,9 @@
 using Internal.Cryptography;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace System.Security.Cryptography
 {
@@ -110,6 +113,128 @@ public static bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination
             return true;
         }
 
+        /// <summary>
+        /// Computes the hash of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA512 algorithm always produces a 512-bit hash, or 64 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static int HashData(Stream source, Span<byte> destination)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA512, HashSizeInBytes, source, destination);
+        }
+
+        /// <summary>
+        /// Computes the hash of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static byte[] HashData(Stream source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStream(HashAlgorithmNames.SHA512, HashSizeInBytes, source);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The hash of the data.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="source" /> does not support reading.
+        /// </exception>
+        public static ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(HashAlgorithmNames.SHA512, HashSizeInBytes, source, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously computes the hash of a stream using the SHA512 algorithm.
+        /// </summary>
+        /// <param name="source">The stream to hash.</param>
+        /// <param name="destination">The buffer to receive the hash value.</param>
+        /// <param name="cancellationToken">
+        ///   The token to monitor for cancellation requests.
+        ///   The default value is <see cref="System.Threading.CancellationToken.None" />.
+        /// </param>
+        /// <returns>The total number of bytes written to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="source" /> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <p>
+        ///   The buffer in <paramref name="destination"/> is too small to hold the calculated hash
+        ///   size. The SHA512 algorithm always produces a 512-bit hash, or 64 bytes.
+        ///   </p>
+        ///   <p>-or-</p>
+        ///   <p>
+        ///   <paramref name="source" /> does not support reading.
+        ///   </p>
+        /// </exception>
+        public static ValueTask<int> HashDataAsync(
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken = default)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (destination.Length < HashSizeInBytes)
+                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
+
+            if (!source.CanRead)
+                throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(source));
+
+            return LiteHashProvider.HashStreamAsync(
+                HashAlgorithmNames.SHA512,
+                HashSizeInBytes,
+                source,
+                destination,
+                cancellationToken);
+        }
+
         private sealed class Implementation : SHA512
         {
             private readonly HashProvider _hashProvider;
diff --git a/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs b/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs
index 9f940b3753a63e..8890808c6a0cca 100644
--- a/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs
@@ -3,6 +3,8 @@
 
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Test.Cryptography;
 using Xunit;
 
@@ -15,6 +17,10 @@ public abstract class HashAlgorithmTestDriver
         protected abstract byte[] HashData(byte[] source);
         protected abstract byte[] HashData(ReadOnlySpan<byte> source);
         protected abstract int HashData(ReadOnlySpan<byte> source, Span<byte> destination);
+        protected abstract int HashData(Stream source, Span<byte> destination);
+        protected abstract byte[] HashData(Stream source);
+        protected abstract ValueTask<int> HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken);
+        protected abstract ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken);
 
         protected void Verify(string input, string output)
         {
@@ -35,6 +41,54 @@ private void VerifyComputeHashStream(Stream input, string output)
             Assert.Equal(expected, actual);
         }
 
+        private async Task VerifyComputeHashStreamAsync(Stream input, string output)
+        {
+            byte[] expected = ByteUtils.HexToByteArray(output);
+            byte[] actual;
+
+            using (HashAlgorithm hash = Create())
+            {
+                Assert.True(hash.HashSize > 0);
+                actual = await hash.ComputeHashAsync(input);
+            }
+
+            Assert.Equal(expected, actual);
+        }
+
+        private void VerifyOneShotStream(Stream input, string output)
+        {
+            byte[] expected = ByteUtils.HexToByteArray(output);
+            Span<byte> buffer = stackalloc byte[512 / 8];
+
+            int written = HashData(input, buffer);
+            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written));
+        }
+
+        private async Task VerifyOneShotStreamAsync(Stream input, string output)
+        {
+            byte[] expected = ByteUtils.HexToByteArray(output);
+            Memory<byte> buffer = new byte[512 / 8];
+
+            int written = await HashDataAsync(input, buffer, cancellationToken: default);
+            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written).Span);
+        }
+
+        private void VerifyOneShotAllocatingStream(Stream input, string output)
+        {
+            byte[] expected = ByteUtils.HexToByteArray(output);
+
+            byte[] digest = HashData(input);
+            Assert.Equal(expected, digest);
+        }
+
+        private async Task VerifyOneShotAllocatingStreamAsync(Stream input, string output)
+        {
+            byte[] expected = ByteUtils.HexToByteArray(output);
+
+            byte[] digest = await HashDataAsync(input, cancellationToken: default);
+            Assert.Equal(expected, digest);
+        }
+
         private void VerifyICryptoTransformStream(Stream input, string output)
         {
             byte[] expected = ByteUtils.HexToByteArray(output);
@@ -140,13 +194,13 @@ private void VerifyTransformBlockComputeHashInteraction(byte[] block1, byte[] bl
         [Fact]
         public void HashData_ByteArray_Null()
         {
-            AssertExtensions.Throws<ArgumentNullException>("source", () => HashData(null));
+            AssertExtensions.Throws<ArgumentNullException>("source", () => HashData((byte[])null));
         }
 
         [Fact]
         public void HashData_BufferTooSmall()
         {
-            AssertExtensions.Throws<ArgumentException>("destination", () => HashData(default, default));
+            AssertExtensions.Throws<ArgumentException>("destination", () => HashData(Span<byte>.Empty, default));
         }
 
         [Fact]
@@ -320,6 +374,85 @@ protected void VerifyRepeating(string input, int repeatCount, string output)
             {
                 VerifyICryptoTransformStream(stream, output);
             }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                VerifyOneShotStream(stream, output);
+            }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                VerifyOneShotAllocatingStream(stream, output);
+            }
+        }
+
+        protected async Task VerifyRepeatingAsync(string input, int repeatCount, string output)
+        {
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                await VerifyComputeHashStreamAsync(stream, output);
+            }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                await VerifyOneShotStreamAsync(stream, output);
+            }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                await VerifyOneShotAllocatingStreamAsync(stream, output);
+            }
+        }
+
+        [Fact]
+        public void HashData_Null_Stream_Throws()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("source", () => HashData((Stream)null));
+            AssertExtensions.Throws<ArgumentNullException>("source", () => HashData((Stream)null, Span<byte>.Empty));
+        }
+
+        [Fact]
+        public void HashData_ShortDestination_Throws()
+        {
+            AssertExtensions.Throws<ArgumentException>("destination", () => HashData(Stream.Null, Span<byte>.Empty));
+        }
+
+        [Fact]
+        public void HashDataAsync_Null_Stream_Throws()
+        {
+            AssertExtensions.Throws<ArgumentNullException>(
+                "source",
+                () => HashDataAsync((Stream)null, cancellationToken: default));
+
+            AssertExtensions.Throws<ArgumentNullException>(
+                "source",
+                () => HashDataAsync((Stream)null, Memory<byte>.Empty, cancellationToken: default));
+        }
+
+        [Fact]
+        public void HashDataAsync_ShortDestination_Throws()
+        {
+            AssertExtensions.Throws<ArgumentException>(
+                "destination",
+                () => HashDataAsync(Stream.Null, Memory<byte>.Empty, cancellationToken: default));
+        }
+
+        [Fact]
+        public void HashDataAsync_Buffer_CancelledToken()
+        {
+            Memory<byte> buffer = new byte[512 / 8];
+            CancellationToken cancelledToken = new CancellationToken(canceled: true);
+            ValueTask<int> waitable = HashDataAsync(Stream.Null, buffer, cancelledToken);
+            Assert.True(waitable.IsCanceled, nameof(waitable.IsCanceled));
+            AssertExtensions.FilledWith<byte>(0, buffer.Span);
+        }
+
+        [Fact]
+        public void HashDataAsync_Allocating_CancelledToken()
+        {
+            CancellationToken cancelledToken = new CancellationToken(canceled: true);
+            ValueTask<byte[]> waitable = HashDataAsync(Stream.Null, cancelledToken);
+            Assert.True(waitable.IsCanceled, nameof(waitable.IsCanceled));
         }
 
         [Fact]
@@ -511,91 +644,5 @@ public void Initialize_DoubleInitialize_Works()
                 Assert.Equal(expectedDigest, hash.Hash);
             }
         }
-
-        protected class DataRepeatingStream : Stream
-        {
-            private int _remaining;
-            private byte[] _data;
-
-            public DataRepeatingStream(string data, int repeatCount)
-            {
-                _remaining = repeatCount;
-                _data = ByteUtils.AsciiBytes(data);
-            }
-
-            public override int Read(byte[] buffer, int offset, int count)
-            {
-                if (!CanRead)
-                {
-                    throw new NotSupportedException();
-                }
-
-                if (_remaining == 0)
-                {
-                    return 0;
-                }
-
-                if (count < _data.Length)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                int multiple = count / _data.Length;
-
-                if (multiple > _remaining)
-                {
-                    multiple = _remaining;
-                }
-
-                int localOffset = offset;
-
-                for (int i = 0; i < multiple; i++)
-                {
-                    Buffer.BlockCopy(_data, 0, buffer, localOffset, _data.Length);
-                    localOffset += _data.Length;
-                }
-
-                _remaining -= multiple;
-                return _data.Length * multiple;
-            }
-
-            protected override void Dispose(bool disposing)
-            {
-                if (disposing)
-                {
-                    _data = null;
-                }
-            }
-
-            public override void Flush()
-            {
-            }
-
-            public override long Seek(long offset, SeekOrigin origin)
-            {
-                throw new NotSupportedException();
-            }
-
-            public override void SetLength(long value)
-            {
-                throw new NotSupportedException();
-            }
-
-            public override void Write(byte[] buffer, int offset, int count)
-            {
-                throw new NotSupportedException();
-            }
-
-            public override bool CanRead { get { return _data != null; } }
-            public override bool CanSeek { get { return false; } }
-            public override bool CanWrite { get { return false; } }
-            public override long Length { get { throw new NotSupportedException(); } }
-
-            public override long Position
-            {
-                get { throw new NotSupportedException(); }
-                set { throw new NotSupportedException(); }
-            }
-        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs b/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs
index 99ad3814d0a371..d658411811826a 100644
--- a/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Test.Cryptography;
 using Xunit;
 
@@ -55,6 +58,31 @@ protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte
         protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
             HMACMD5.TryHashData(key, source, destination, out written);
 
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, Stream source) =>
+            HMACMD5.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(byte[] key, Stream source) =>
+            HMACMD5.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) =>
+            HMACMD5.HashData(key, source, destination);
+
+        protected override ValueTask<int> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken) => HMACMD5.HashDataAsync(key, source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACMD5.HashDataAsync(key, source, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            byte[] key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACMD5.HashDataAsync(key, source, cancellationToken);
+
         [Fact]
         public void HmacMD5_Rfc2202_1()
         {
@@ -108,5 +136,77 @@ public void HMacMD5_ThrowsArgumentNullForNullConstructorKey()
         {
             AssertExtensions.Throws<ArgumentNullException>("key", () => new HMACMD5(null));
         }
+
+        [Fact]
+        public void HmacMD5_Stream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl md5 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "1287EF250C2026A0C0CBA832C599AE50");
+        }
+
+        [Fact]
+        public void HmacMD5_Stream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl md5 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "D10B835D95FCC9EECDF1D4BCDAB81897");
+        }
+
+        [Fact]
+        public void HmacMD5_Stream_Empty()
+        {
+            // Verfied with:
+            // echo -n "" | openssl md5 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "C91E40247251F39BDFE6A7B72A5857F9");
+        }
+
+        [Fact]
+        public async Task HmacMD5_Stream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl md5 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "1287EF250C2026A0C0CBA832C599AE50");
+        }
+
+        [Fact]
+        public async Task HmacMD5_Stream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl md5 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "D10B835D95FCC9EECDF1D4BCDAB81897");
+        }
+
+        [Fact]
+        public async Task HmacMD5_Stream_Empty_Async()
+        {
+            // Verfied with:
+            // echo -n "" | openssl md5 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "C91E40247251F39BDFE6A7B72A5857F9");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacSha1Tests.cs b/src/libraries/System.Security.Cryptography/tests/HmacSha1Tests.cs
index 61b395d572535c..d618b7122a32d3 100644
--- a/src/libraries/System.Security.Cryptography/tests/HmacSha1Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HmacSha1Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Test.Cryptography;
 using Xunit;
 
@@ -55,6 +58,31 @@ protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte
         protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
             HMACSHA1.TryHashData(key, source, destination, out written);
 
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, Stream source) =>
+            HMACSHA1.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(byte[] key, Stream source) =>
+            HMACSHA1.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) =>
+            HMACSHA1.HashData(key, source, destination);
+
+        protected override ValueTask<int> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken) => HMACSHA1.HashDataAsync(key, source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA1.HashDataAsync(key, source, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            byte[] key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA1.HashDataAsync(key, source, cancellationToken);
+
         [Fact]
         public void HmacSha1_Byte_Constructors()
         {
@@ -128,9 +156,81 @@ public void HmacSha1_Rfc2202_7()
         }
 
         [Fact]
-        public void HMacSha1_Rfc2104_2()
+        public void HmacSha1_Rfc2104_2()
         {
             VerifyHmacRfc2104_2();
         }
+
+        [Fact]
+        public void HmacSha1_Stream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha1 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "3CE5AE476733905861F031DDC2DEDF8CBB1FAA0B");
+        }
+
+        [Fact]
+        public void HmacSha1_Stream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha1 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "E18D7FB16A83CA17DB6CB0F1C083AA7A7094F627");
+        }
+
+        [Fact]
+        public void HmacSha1_Stream_Empty()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha1 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "5433122F77BCF8A4D9B874B4149823EF5B7C207E");
+        }
+
+        [Fact]
+        public async Task HmacSha1_Stream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha1 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "3CE5AE476733905861F031DDC2DEDF8CBB1FAA0B");
+        }
+
+        [Fact]
+        public async Task HmacSha1_Stream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha1 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "E18D7FB16A83CA17DB6CB0F1C083AA7A7094F627");
+        }
+
+        [Fact]
+        public async Task HmacSha1_Stream_Empty_Async()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha1 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "5433122F77BCF8A4D9B874B4149823EF5B7C207E");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacSha256Tests.cs b/src/libraries/System.Security.Cryptography/tests/HmacSha256Tests.cs
index f2f17844046756..587711a920ad27 100644
--- a/src/libraries/System.Security.Cryptography/tests/HmacSha256Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HmacSha256Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Test.Cryptography;
 using Xunit;
 
@@ -26,6 +29,31 @@ protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte
         protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
             HMACSHA256.TryHashData(key, source, destination, out written);
 
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, Stream source) =>
+            HMACSHA256.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(byte[] key, Stream source) =>
+            HMACSHA256.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) =>
+            HMACSHA256.HashData(key, source, destination);
+
+        protected override ValueTask<int> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken) => HMACSHA256.HashDataAsync(key, source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA256.HashDataAsync(key, source, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            byte[] key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA256.HashDataAsync(key, source, cancellationToken);
+
         private static byte[][] s_testMacs4231 =
         {
             null,
@@ -86,7 +114,7 @@ public void HmacSha256_Rfc4231_7()
         }
 
         [Fact]
-        public void HMacSha256_Rfc2104_2()
+        public void HmacSha256_Rfc2104_2()
         {
             VerifyHmacRfc2104_2();
         }
@@ -96,5 +124,77 @@ public void HmacSha256_ThrowsArgumentNullForNullConstructorKey()
         {
             AssertExtensions.Throws<ArgumentNullException>("key", () => new HMACSHA256(null));
         }
+
+        [Fact]
+        public void HmacSha256_Stream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha256 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "A47B9F5BD5C2DEF403A0279D4C6C407A2D34561E7D1F006D7FE8BDC2C78227D5");
+        }
+
+        [Fact]
+        public void HmacSha256_Stream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha256 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "1CF6661B6EFD25D8B6DE734AA39D5D3D44C9A56BB9377A6388EB0FC5E48A108B");
+        }
+
+        [Fact]
+        public void HmacSha256_Stream_Empty()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha256 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "07EFF8B326B7798C9CCFCBDBE579489AC785A7995A04618B1A2813C26744777D");
+        }
+
+        [Fact]
+        public async Task HmacSha256_Stream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha256 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "A47B9F5BD5C2DEF403A0279D4C6C407A2D34561E7D1F006D7FE8BDC2C78227D5");
+        }
+
+        [Fact]
+        public async Task HmacSha256_Stream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha256 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "1CF6661B6EFD25D8B6DE734AA39D5D3D44C9A56BB9377A6388EB0FC5E48A108B");
+        }
+
+        [Fact]
+        public async Task HmacSha256_Stream_Empty_Async()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha256 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "07EFF8B326B7798C9CCFCBDBE579489AC785A7995A04618B1A2813C26744777D");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacSha384Tests.cs b/src/libraries/System.Security.Cryptography/tests/HmacSha384Tests.cs
index dbff8c26c50bcd..eb3bbf5681e8b8 100644
--- a/src/libraries/System.Security.Cryptography/tests/HmacSha384Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HmacSha384Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Test.Cryptography;
 using Xunit;
 
@@ -26,6 +29,31 @@ protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte
         protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
             HMACSHA384.TryHashData(key, source, destination, out written);
 
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, Stream source) =>
+            HMACSHA384.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(byte[] key, Stream source) =>
+            HMACSHA384.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) =>
+            HMACSHA384.HashData(key, source, destination);
+
+        protected override ValueTask<int> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken) => HMACSHA384.HashDataAsync(key, source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA384.HashDataAsync(key, source, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            byte[] key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA384.HashDataAsync(key, source, cancellationToken);
+
         private static byte[][] s_testMacs4231 =
         {
             null,
@@ -99,7 +127,7 @@ public void HmacSha384_Rfc4231_7()
         }
 
         [Fact]
-        public void HMacSha384_Rfc2104_2()
+        public void HmacSha384_Rfc2104_2()
         {
             VerifyHmacRfc2104_2();
         }
@@ -109,5 +137,77 @@ public void HmacSha384_ThrowsArgumentNullForNullConstructorKey()
         {
             AssertExtensions.Throws<ArgumentNullException>("key", () => new HMACSHA384(null));
         }
+
+        [Fact]
+        public void HmacSha384_Stream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha384 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "6C4977B00CCE179ADCC06EB35E48ABDE9B5604FC9E8B6B25F65E0234EE6394DE40F0C6C6B727B58B19ADFC1E5BB2E84D");
+        }
+
+        [Fact]
+        public void HmacSha384_Stream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha384 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "45303A3B5F02C8462D6FA438893DAA05EFFA850B853DF614D45F343D20AFE6D6DBAC6D0656788C4398EDF0AEC01488D4");
+        }
+
+        [Fact]
+        public void HmacSha384_Stream_Empty()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha384 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "6A0FDC1C54C664AD91C7C157D2670C5D44E4D44EBAD2359A0206974C7088B1A867F76971E6C240C33B33A66BA295BB56");
+        }
+
+        [Fact]
+        public async Task HmacSha384_Stream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha384 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "6C4977B00CCE179ADCC06EB35E48ABDE9B5604FC9E8B6B25F65E0234EE6394DE40F0C6C6B727B58B19ADFC1E5BB2E84D");
+        }
+
+        [Fact]
+        public async Task HmacSha384_Stream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha384 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "45303A3B5F02C8462D6FA438893DAA05EFFA850B853DF614D45F343D20AFE6D6DBAC6D0656788C4398EDF0AEC01488D4");
+        }
+
+        [Fact]
+        public async Task HmacSha384_Stream_Empty_Async()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha384 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "6A0FDC1C54C664AD91C7C157D2670C5D44E4D44EBAD2359A0206974C7088B1A867F76971E6C240C33B33A66BA295BB56");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacSha512Tests.cs b/src/libraries/System.Security.Cryptography/tests/HmacSha512Tests.cs
index 7bf5ed66528733..7172d68d43dfe7 100644
--- a/src/libraries/System.Security.Cryptography/tests/HmacSha512Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HmacSha512Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Test.Cryptography;
 using Xunit;
 
@@ -26,6 +29,31 @@ protected override int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte
         protected override bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written) =>
             HMACSHA512.TryHashData(key, source, destination, out written);
 
+        protected override byte[] HashDataOneShot(ReadOnlySpan<byte> key, Stream source) =>
+            HMACSHA512.HashData(key, source);
+
+        protected override byte[] HashDataOneShot(byte[] key, Stream source) =>
+            HMACSHA512.HashData(key, source);
+
+        protected override int HashDataOneShot(ReadOnlySpan<byte> key, Stream source, Span<byte> destination) =>
+            HMACSHA512.HashData(key, source, destination);
+
+        protected override ValueTask<int> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken) => HMACSHA512.HashDataAsync(key, source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA512.HashDataAsync(key, source, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataOneShotAsync(
+            byte[] key,
+            Stream source,
+            CancellationToken cancellationToken) => HMACSHA512.HashDataAsync(key, source, cancellationToken);
+
         private static byte[][] s_testMacs4231 =
         {
             null,
@@ -99,7 +127,7 @@ public void HmacSha512_Rfc4231_7()
         }
 
         [Fact]
-        public void HMacSha512_Rfc2104_2()
+        public void HmacSha512_Rfc2104_2()
         {
             VerifyHmacRfc2104_2();
         }
@@ -109,5 +137,77 @@ public void HmacSha512_ThrowsArgumentNullForNullConstructorKey()
         {
             AssertExtensions.Throws<ArgumentNullException>("key", () => new HMACSHA512(null));
         }
+
+        [Fact]
+        public void HmacSha512_Stream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha512 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "05A7BB210D374B0CC36FFFA561045F1C1EB8E71905A50308B108D4677CCB0452A99B26EE41DD8E1D87D53A4F3E07B1231E5D3FFFCE7FD0C5C5A8B8F5E0206A11");
+        }
+
+        [Fact]
+        public void HmacSha512_Stream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha512 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "9040E87E9CC546C507C3DEE90D278975B0C2049F28E71CC6FEEA0F3690EC9D0B736F885FFAA611156DA0C2904FC2EEEAA9562B53EB50F590902B2AE38056C874");
+        }
+
+        [Fact]
+        public void HmacSha512_Stream_Empty()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha512 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            VerifyRepeating(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "2FEC800CA276C44985A35AEC92067E5E53A1BB80A6FDAB1D9C97D54068118F30AD4C33717466D372EA00BBF126E5B79C6F7143DD36C31F72028330E92AE3A359");
+        }
+
+        [Fact]
+        public async Task HmacSha512_Stream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl sha512 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1024,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "05A7BB210D374B0CC36FFFA561045F1C1EB8E71905A50308B108D4677CCB0452A99B26EE41DD8E1D87D53A4F3E07B1231E5D3FFFCE7FD0C5C5A8B8F5E0206A11");
+        }
+
+        [Fact]
+        public async Task HmacSha512_Stream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl sha512 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "0102030405060708",
+                1025,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "9040E87E9CC546C507C3DEE90D278975B0C2049F28E71CC6FEEA0F3690EC9D0B736F885FFAA611156DA0C2904FC2EEEAA9562B53EB50F590902B2AE38056C874");
+        }
+
+        [Fact]
+        public async Task HmacSha512_Stream_Empty_Async()
+        {
+            // Verfied with:
+            // echo -n "" | openssl sha512 -hex -mac HMAC -macopt hexkey:000102030405060708090A0B0C0D0E0F
+            await VerifyRepeatingAsync(
+                input: "",
+                0,
+                hexKey: "000102030405060708090A0B0C0D0E0F",
+                output: "2FEC800CA276C44985A35AEC92067E5E53A1BB80A6FDAB1D9C97D54068118F30AD4C33717466D372EA00BBF126E5B79C6F7143DD36C31F72028330E92AE3A359");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacTests.cs b/src/libraries/System.Security.Cryptography/tests/HmacTests.cs
index ca266b43921fe4..9083a9fd15e7b5 100644
--- a/src/libraries/System.Security.Cryptography/tests/HmacTests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/HmacTests.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Test.Cryptography;
 using Xunit;
 
@@ -31,10 +33,123 @@ protected HmacTests(byte[][] testKeys, byte[][] testData, byte[][] testMacs)
         protected abstract byte[] HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source);
         protected abstract int HashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination);
         protected abstract bool TryHashDataOneShot(ReadOnlySpan<byte> key, ReadOnlySpan<byte> source, Span<byte> destination, out int written);
+        protected abstract byte[] HashDataOneShot(ReadOnlySpan<byte> key, Stream source);
+        protected abstract byte[] HashDataOneShot(byte[] key, Stream source);
+        protected abstract int HashDataOneShot(ReadOnlySpan<byte> key, Stream source, Span<byte> destination);
+
+        protected abstract ValueTask<int> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            Memory<byte> destination,
+            CancellationToken cancellationToken);
+
+        protected abstract ValueTask<byte[]> HashDataOneShotAsync(
+            ReadOnlyMemory<byte> key,
+            Stream source,
+            CancellationToken cancellationToken);
+
+        protected abstract ValueTask<byte[]> HashDataOneShotAsync(
+            byte[] key,
+            Stream source,
+            CancellationToken cancellationToken);
 
         protected abstract int BlockSize { get; }
         protected abstract int MacSize { get; }
 
+        protected void VerifyRepeating(string input, int repeatCount, string hexKey, string output)
+        {
+            byte[] key = ByteUtils.HexToByteArray(hexKey);
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                VerifyHashDataStreamAllocating(key, stream, output, spanKey: true);
+            }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                VerifyHashDataStreamAllocating(key, stream, output, spanKey: false);
+            }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                VerifyHashDataStream(key, stream, output);
+            }
+        }
+
+        protected async Task VerifyRepeatingAsync(string input, int repeatCount, string hexKey, string output)
+        {
+            byte[] key = ByteUtils.HexToByteArray(hexKey);
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                await VerifyHashDataStreamAllocatingAsync(key, stream, output, memoryKey: true);
+            }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                await VerifyHashDataStreamAllocatingAsync(key, stream, output, memoryKey: false);
+            }
+
+            using (Stream stream = new DataRepeatingStream(input, repeatCount))
+            {
+                await VerifyHashDataStreamAsync(key, stream, output);
+            }
+        }
+
+        protected void VerifyHashDataStream(ReadOnlySpan<byte> key, Stream stream, string output)
+        {
+            Span<byte> destination = stackalloc byte[MacSize];
+            byte[] expected = ByteUtils.HexToByteArray(output);
+            int written = HashDataOneShot(key, stream, destination);
+
+            Assert.Equal(MacSize, written);
+            AssertExtensions.SequenceEqual(expected, destination);
+        }
+
+        protected async Task VerifyHashDataStreamAsync(ReadOnlyMemory<byte> key, Stream stream, string output)
+        {
+            Memory<byte> destination = new byte[MacSize];
+            byte[] expected = ByteUtils.HexToByteArray(output);
+            int written = await HashDataOneShotAsync(key, stream, destination, cancellationToken: default);
+
+            Assert.Equal(MacSize, written);
+            AssertExtensions.SequenceEqual(expected, destination.Span);
+        }
+
+        protected void VerifyHashDataStreamAllocating(byte[] key, Stream stream, string output, bool spanKey)
+        {
+            byte[] expected = ByteUtils.HexToByteArray(output);
+            byte[] hmac;
+
+            if (spanKey)
+            {
+                hmac = HashDataOneShot(key.AsSpan(), stream);
+            }
+            else
+            {
+                hmac = HashDataOneShot(key, stream);
+            }
+
+            Assert.Equal(expected, hmac);
+        }
+
+        protected async Task VerifyHashDataStreamAllocatingAsync(byte[] key, Stream stream, string output, bool memoryKey)
+        {
+            byte[] expected = ByteUtils.HexToByteArray(output);
+            byte[] hmac;
+
+            if (memoryKey)
+            {
+                hmac = await HashDataOneShotAsync(new ReadOnlyMemory<byte>(key), stream, cancellationToken: default);
+            }
+            else
+            {
+                hmac = await HashDataOneShotAsync(key, stream, cancellationToken: default);
+            }
+
+            Assert.Equal(expected, hmac);
+        }
+
         protected void VerifyHmac(int testCaseId, byte[] digestBytes)
         {
             byte[] data = _testData[testCaseId];
@@ -386,5 +501,111 @@ public void OneShot_Empty_Matches_Instances(byte[] key, byte[] source)
                 Assert.Equal(mac, oneShot);
             }
         }
+
+        [Fact]
+        public void HashData_Stream_Source_Null()
+        {
+            AssertExtensions.Throws<ArgumentNullException>(
+                "source",
+                () => HashDataOneShot(ReadOnlySpan<byte>.Empty, (Stream)null));
+
+            AssertExtensions.Throws<ArgumentNullException>(
+                "source",
+                () => HashDataOneShot(Array.Empty<byte>(), (Stream)null));
+        }
+
+        [Fact]
+        public void HashData_Stream_Source_Null_Async()
+        {
+            AssertExtensions.Throws<ArgumentNullException>(
+                "source",
+                () => HashDataOneShotAsync(ReadOnlyMemory<byte>.Empty, (Stream)null, default));
+
+            AssertExtensions.Throws<ArgumentNullException>(
+                "source",
+                () => HashDataOneShotAsync(Array.Empty<byte>(), (Stream)null, default));
+        }
+
+        [Fact]
+        public void HashData_Stream_ByteKey_Null()
+        {
+            AssertExtensions.Throws<ArgumentNullException>(
+                "key",
+                () => HashDataOneShot((byte[])null, Stream.Null));
+        }
+
+        [Fact]
+        public void HashData_Stream_ByteKey_Null_Async()
+        {
+            AssertExtensions.Throws<ArgumentNullException>(
+                "key",
+                () => HashDataOneShotAsync((byte[])null, Stream.Null, default));
+        }
+
+        [Fact]
+        public void HashData_Stream_DestinationTooSmall()
+        {
+            byte[] destination = new byte[MacSize - 1];
+
+            AssertExtensions.Throws<ArgumentException>(
+                "destination",
+                () => HashDataOneShot(Array.Empty<byte>(), Stream.Null, destination));
+            AssertExtensions.FilledWith<byte>(0, destination);
+
+            AssertExtensions.Throws<ArgumentException>(
+                "destination",
+                () => HashDataOneShot(ReadOnlySpan<byte>.Empty, Stream.Null, destination));
+            AssertExtensions.FilledWith<byte>(0, destination);
+        }
+
+        [Fact]
+        public void HashData_Stream_DestinationTooSmall_Async()
+        {
+            byte[] destination = new byte[MacSize - 1];
+
+            AssertExtensions.Throws<ArgumentException>(
+                "destination",
+                () => HashDataOneShotAsync(Array.Empty<byte>(), Stream.Null, destination, default));
+            AssertExtensions.FilledWith<byte>(0, destination);
+
+            AssertExtensions.Throws<ArgumentException>(
+                "destination",
+                () => HashDataOneShotAsync(ReadOnlyMemory<byte>.Empty, Stream.Null, destination, default));
+            AssertExtensions.FilledWith<byte>(0, destination);
+        }
+
+        [Fact]
+        public void HashData_Stream_NotReadable()
+        {
+            AssertExtensions.Throws<ArgumentException>(
+                "source",
+                () => HashDataOneShot(Array.Empty<byte>(), UntouchableStream.Instance));
+
+            AssertExtensions.Throws<ArgumentException>(
+                "source",
+                () => HashDataOneShot(ReadOnlySpan<byte>.Empty, UntouchableStream.Instance));
+        }
+
+        [Fact]
+        public void HashData_Stream_Cancelled()
+        {
+            Memory<byte> buffer = new byte[512 / 8];
+            CancellationToken cancelledToken = new CancellationToken(canceled: true);
+            ValueTask<int> waitable = HashDataOneShotAsync(ReadOnlyMemory<byte>.Empty, Stream.Null, buffer, cancelledToken);
+            Assert.True(waitable.IsCanceled, nameof(waitable.IsCanceled));
+            AssertExtensions.FilledWith<byte>(0, buffer.Span);
+
+            waitable = HashDataOneShotAsync(Array.Empty<byte>(), Stream.Null, buffer, cancelledToken);
+            Assert.True(waitable.IsCanceled, nameof(waitable.IsCanceled));
+            AssertExtensions.FilledWith<byte>(0, buffer.Span);
+        }
+
+        [Fact]
+        public void HashData_Stream_Allocating_Cancelled()
+        {
+            CancellationToken cancelledToken = new CancellationToken(canceled: true);
+            ValueTask<byte[]> waitable = HashDataOneShotAsync(ReadOnlyMemory<byte>.Empty, Stream.Null, cancelledToken);
+            Assert.True(waitable.IsCanceled, nameof(waitable.IsCanceled));
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/MD5Tests.cs b/src/libraries/System.Security.Cryptography/tests/MD5Tests.cs
index e301eae2fc3001..26ab965bf4799f 100644
--- a/src/libraries/System.Security.Cryptography/tests/MD5Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/MD5Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace System.Security.Cryptography.Tests
@@ -25,6 +28,49 @@ protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destin
         protected override int HashData(ReadOnlySpan<byte> source, Span<byte> destination) =>
             MD5.HashData(source, destination);
 
+        protected override int HashData(Stream source, Span<byte> destination) =>
+            MD5.HashData(source, destination);
+
+        protected override byte[] HashData(Stream source) => MD5.HashData(source);
+
+        protected override ValueTask<int> HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken) =>
+            MD5.HashDataAsync(source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken) =>
+            MD5.HashDataAsync(source, cancellationToken);
+
+        [Fact]
+        public void MD5_VerifyLargeStream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -md5
+            VerifyRepeating("0102030405060708", 1024, "5fc6366852074da6e4795a014574282c");
+        }
+
+        [Fact]
+        public void MD5_VerifyLargeStream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -md5
+            VerifyRepeating("0102030405060708", 1025, "c5f6181a24446a583b14282f32786513");
+        }
+
+        [Fact]
+        public async Task MD5_VerifyLargeStream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -md5
+            await VerifyRepeatingAsync("0102030405060708", 1025, "c5f6181a24446a583b14282f32786513");
+        }
+
+        [Fact]
+        public async Task MD5_VerifyLargeStream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -md5
+            await VerifyRepeatingAsync("0102030405060708", 1024, "5fc6366852074da6e4795a014574282c");
+        }
+
         // Test cases are defined in RFC 1321, section A.5
 
         [Fact]
@@ -79,10 +125,28 @@ public void MD5_Rfc1321_7()
             Verify("12345678901234567890123456789012345678901234567890123456789012345678901234567890", "57edf4a22be3c955ac49da2e2107b67a");
         }
 
+        [Fact]
+        public void MD5_Rfc1321_1_AsStream()
+        {
+            VerifyRepeating(string.Empty, 0, "d41d8cd98f00b204e9800998ecf8427e");
+        }
+
         [Fact]
         public void MD5_Rfc1321_7_AsStream()
         {
             VerifyRepeating("1234567890", 8, "57edf4a22be3c955ac49da2e2107b67a");
         }
+
+        [Fact]
+        public async Task MD5_Rfc1321_1_AsStream_Async()
+        {
+            await VerifyRepeatingAsync(string.Empty, 0, "d41d8cd98f00b204e9800998ecf8427e");
+        }
+
+        [Fact]
+        public async Task MD5_Rfc1321_7_AsStream_Async()
+        {
+            await VerifyRepeatingAsync("1234567890", 8, "57edf4a22be3c955ac49da2e2107b67a");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/Sha1Tests.cs b/src/libraries/System.Security.Cryptography/tests/Sha1Tests.cs
index 45d0315852cbe5..46f0f24534348f 100644
--- a/src/libraries/System.Security.Cryptography/tests/Sha1Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/Sha1Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace System.Security.Cryptography.Tests
@@ -24,12 +27,67 @@ protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destin
         protected override int HashData(ReadOnlySpan<byte> source, Span<byte> destination) =>
             SHA1.HashData(source, destination);
 
+        protected override int HashData(Stream source, Span<byte> destination) =>
+            SHA1.HashData(source, destination);
+
+        protected override byte[] HashData(Stream source) => SHA1.HashData(source);
+
+        protected override ValueTask<int> HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken) =>
+            SHA1.HashDataAsync(source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken) =>
+            SHA1.HashDataAsync(source, cancellationToken);
+
         [Fact]
         public void Sha1_Empty()
         {
             Verify(Array.Empty<byte>(), "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709");
         }
 
+        [Fact]
+        public void Sha1_Empty_Stream()
+        {
+            VerifyRepeating("", 0, "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709");
+        }
+
+        [Fact]
+        public async Task Sha1_Empty_Stream_Async()
+        {
+            await VerifyRepeatingAsync("", 0, "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709");
+        }
+
+        [Fact]
+        public void Sha1_VerifyLargeStream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha1
+            VerifyRepeating("0102030405060708", 1024, "fc8053215c935a5e9cdc51b94bb40b3e66128d41");
+        }
+
+        [Fact]
+        public void Sha1_VerifyLargeStream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha1
+            VerifyRepeating("0102030405060708", 1025, "18c6aa8d255c47941958729faaae9614c9793bb2");
+        }
+
+        [Fact]
+        public async Task Sha1_VerifyLargeStream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha1
+            await VerifyRepeatingAsync("0102030405060708", 1025, "18c6aa8d255c47941958729faaae9614c9793bb2");
+        }
+
+        [Fact]
+        public async Task Sha1_VerifyLargeStream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha1
+            await VerifyRepeatingAsync("0102030405060708", 1024, "fc8053215c935a5e9cdc51b94bb40b3e66128d41");
+        }
+
         // SHA1 tests are defined somewhat obliquely within RFC 3174, section 7.3
         // The same tests appear in http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf Appendix A
         [Fact]
@@ -61,5 +119,17 @@ public void Sha1_Rfc3174_4()
         {
             VerifyRepeating("0123456701234567012345670123456701234567012345670123456701234567", 10, "DEA356A2CDDD90C7A7ECEDC5EBB563934F460452");
         }
+
+        [Fact]
+        public async Task Sha1_Rfc3174_3_Async()
+        {
+            await VerifyRepeatingAsync("a", 1000000, "34AA973CD4C4DAA4F61EEB2BDBAD27316534016F");
+        }
+
+        [Fact]
+        public async Task Sha1_Rfc3174_4_Async()
+        {
+            await VerifyRepeatingAsync("0123456701234567012345670123456701234567012345670123456701234567", 10, "DEA356A2CDDD90C7A7ECEDC5EBB563934F460452");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/Sha256Tests.cs b/src/libraries/System.Security.Cryptography/tests/Sha256Tests.cs
index e85dddc08d7971..4abad52b940941 100644
--- a/src/libraries/System.Security.Cryptography/tests/Sha256Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/Sha256Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace System.Security.Cryptography.Tests
@@ -24,6 +27,17 @@ protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destin
         protected override int HashData(ReadOnlySpan<byte> source, Span<byte> destination) =>
             SHA256.HashData(source, destination);
 
+        protected override int HashData(Stream source, Span<byte> destination) =>
+            SHA256.HashData(source, destination);
+
+        protected override byte[] HashData(Stream source) => SHA256.HashData(source);
+
+        protected override ValueTask<int> HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken) =>
+            SHA256.HashDataAsync(source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken) =>
+            SHA256.HashDataAsync(source, cancellationToken);
+
         [Fact]
         public void Sha256_Empty()
         {
@@ -32,6 +46,62 @@ public void Sha256_Empty()
                 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
         }
 
+        [Fact]
+        public void Sha256_Empty_Stream()
+        {
+            VerifyRepeating("", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+        }
+
+        [Fact]
+        public async Task Sha256_Empty_Stream_Async()
+        {
+            await VerifyRepeatingAsync("", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+        }
+
+        [Fact]
+        public void Sha256_VerifyLargeStream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha256
+            VerifyRepeating(
+                "0102030405060708",
+                1024,
+                "cedca4ad2cce0d0b399931708684800cd16be396ffa5af51297a091650aa3610");
+        }
+
+        [Fact]
+        public void Sha256_VerifyLargeStream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha256
+            VerifyRepeating(
+                "0102030405060708",
+                1025,
+                "9e2e99445f5349c379ceb4c995dde401f63012422183a411d02eb251b1e02e65");
+        }
+
+        [Fact]
+        public async Task Sha256_VerifyLargeStream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha256
+            await VerifyRepeatingAsync(
+                "0102030405060708",
+                1025,
+                "9e2e99445f5349c379ceb4c995dde401f63012422183a411d02eb251b1e02e65");
+        }
+
+        [Fact]
+        public async Task Sha256_VerifyLargeStream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha256
+            await VerifyRepeatingAsync(
+                "0102030405060708",
+                1024,
+                "cedca4ad2cce0d0b399931708684800cd16be396ffa5af51297a091650aa3610");
+        }
+
         // These test cases are from http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf Appendix B
         [Fact]
         public void Sha256_Fips180_1()
@@ -67,5 +137,14 @@ public void Sha256_Fips180_3()
                 1000000,
                 "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
         }
+
+        [Fact]
+        public async Task Sha256_Fips180_3_Async()
+        {
+            await VerifyRepeatingAsync(
+                "a",
+                1000000,
+                "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/Sha384Tests.cs b/src/libraries/System.Security.Cryptography/tests/Sha384Tests.cs
index 5ef3ebcb4e039e..c7cfea805683c7 100644
--- a/src/libraries/System.Security.Cryptography/tests/Sha384Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/Sha384Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace System.Security.Cryptography.Tests
@@ -24,6 +27,17 @@ protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destin
         protected override int HashData(ReadOnlySpan<byte> source, Span<byte> destination) =>
             SHA384.HashData(source, destination);
 
+        protected override int HashData(Stream source, Span<byte> destination) =>
+            SHA384.HashData(source, destination);
+
+        protected override byte[] HashData(Stream source) => SHA384.HashData(source);
+
+        protected override ValueTask<int> HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken) =>
+            SHA384.HashDataAsync(source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken) =>
+            SHA384.HashDataAsync(source, cancellationToken);
+
         [Fact]
         public void Sha384_Empty()
         {
@@ -32,6 +46,68 @@ public void Sha384_Empty()
                 "38B060A751AC96384CD9327EB1B1E36A21FDB71114BE07434C0CC7BF63F6E1DA274EDEBFE76F65FBD51AD2F14898B95B");
         }
 
+        [Fact]
+        public void Sha384_Empty_Stream()
+        {
+            VerifyRepeating(
+                "",
+                0,
+                "38B060A751AC96384CD9327EB1B1E36A21FDB71114BE07434C0CC7BF63F6E1DA274EDEBFE76F65FBD51AD2F14898B95B");
+        }
+
+        [Fact]
+        public async Task Sha384_Empty_Stream_Async()
+        {
+            await VerifyRepeatingAsync(
+                "",
+                0,
+                "38B060A751AC96384CD9327EB1B1E36A21FDB71114BE07434C0CC7BF63F6E1DA274EDEBFE76F65FBD51AD2F14898B95B");
+        }
+
+        [Fact]
+        public void Sha384_VerifyLargeStream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha384
+            VerifyRepeating(
+                "0102030405060708",
+                1024,
+                "d9deec18b8ec0d31270eaeaaf3bcb1de55f1d81482a55d2c023bad873175f1694d8c28e8138d9147dc180e679cd79c58");
+        }
+
+        [Fact]
+        public void Sha384_VerifyLargeStream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha384
+            VerifyRepeating(
+                "0102030405060708",
+                1025,
+                "35cf18493364379093c7def8477330f817f9045d2e311d721730b24d98c9d9e9761c7f27821742e0c236509627aea7fa");
+        }
+
+        [Fact]
+        public async Task Sha384_VerifyLargeStream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha384
+            await VerifyRepeatingAsync(
+                "0102030405060708",
+                1025,
+                "35cf18493364379093c7def8477330f817f9045d2e311d721730b24d98c9d9e9761c7f27821742e0c236509627aea7fa");
+        }
+
+        [Fact]
+        public async Task Sha384_VerifyLargeStream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha384
+            await VerifyRepeatingAsync(
+                "0102030405060708",
+                1024,
+                "d9deec18b8ec0d31270eaeaaf3bcb1de55f1d81482a55d2c023bad873175f1694d8c28e8138d9147dc180e679cd79c58");
+        }
+
         // These test cases are from http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/SHA_All.pdf
         [Fact]
         public void Sha384_NistShaAll_1()
@@ -42,7 +118,7 @@ public void Sha384_NistShaAll_1()
         }
 
         [Fact]
-        public void Sha256_Fips180_MultiBlock()
+        public void Sha384_Fips180_MultiBlock()
         {
             VerifyMultiBlock(
                 "a",
diff --git a/src/libraries/System.Security.Cryptography/tests/Sha512Tests.cs b/src/libraries/System.Security.Cryptography/tests/Sha512Tests.cs
index 4586a08d846b07..465f41c15fdf69 100644
--- a/src/libraries/System.Security.Cryptography/tests/Sha512Tests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/Sha512Tests.cs
@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace System.Security.Cryptography.Tests
@@ -24,6 +27,17 @@ protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destin
         protected override int HashData(ReadOnlySpan<byte> source, Span<byte> destination) =>
             SHA512.HashData(source, destination);
 
+        protected override int HashData(Stream source, Span<byte> destination) =>
+            SHA512.HashData(source, destination);
+
+        protected override byte[] HashData(Stream source) => SHA512.HashData(source);
+
+        protected override ValueTask<int> HashDataAsync(Stream source, Memory<byte> destination, CancellationToken cancellationToken) =>
+            SHA512.HashDataAsync(source, destination, cancellationToken);
+
+        protected override ValueTask<byte[]> HashDataAsync(Stream source, CancellationToken cancellationToken) =>
+            SHA512.HashDataAsync(source, cancellationToken);
+
         [Fact]
         public void Sha512_Empty()
         {
@@ -32,6 +46,68 @@ public void Sha512_Empty()
                 "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
         }
 
+        [Fact]
+        public void Sha512_Empty_Stream()
+        {
+            VerifyRepeating(
+                "",
+                0,
+                "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
+        }
+
+        [Fact]
+        public async Task Sha512_Empty_Stream_Async()
+        {
+            await VerifyRepeatingAsync(
+                "",
+                0,
+                "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
+        }
+
+        [Fact]
+        public void Sha512_VerifyLargeStream_MultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha512
+            VerifyRepeating(
+                "0102030405060708",
+                1024,
+                "da1bdf4632ea5ee0724a57a9bc6fd409d7f8f7417373356281ce36f82b510da95c7dff7d64a43b3cf4854894e124f56b349749a3f76b41611c01fee739f4d923");
+        }
+
+        [Fact]
+        public void Sha512_VerifyLargeStream_NotMultipleOf4096()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha512
+            VerifyRepeating(
+                "0102030405060708",
+                1025,
+                "65de1e49167977ade93d12115d0f5915a988b7e0ab73f2b554bd6d87c17155e865ba434a88271fb2dbaf5f9b0cf71d627eaea6b0efce5ec95e4c6017bfbfb34b");
+        }
+
+        [Fact]
+        public async Task Sha512_VerifyLargeStream_NotMultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1025}; do echo -n "0102030405060708"; done | openssl dgst -sha512
+            await VerifyRepeatingAsync(
+                "0102030405060708",
+                1025,
+                "65de1e49167977ade93d12115d0f5915a988b7e0ab73f2b554bd6d87c17155e865ba434a88271fb2dbaf5f9b0cf71d627eaea6b0efce5ec95e4c6017bfbfb34b");
+        }
+
+        [Fact]
+        public async Task Sha512_VerifyLargeStream_MultipleOf4096_Async()
+        {
+            // Verfied with:
+            // for _ in {1..1024}; do echo -n "0102030405060708"; done | openssl dgst -sha512
+            await VerifyRepeatingAsync(
+                "0102030405060708",
+                1024,
+                "da1bdf4632ea5ee0724a57a9bc6fd409d7f8f7417373356281ce36f82b510da95c7dff7d64a43b3cf4854894e124f56b349749a3f76b41611c01fee739f4d923");
+        }
+
         // These test cases are from http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf Appendix C
         [Fact]
         public void Sha512_Fips180_1()
@@ -67,5 +143,14 @@ public void Sha512_Fips180_3()
                 1000000,
                 "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b");
         }
+
+        [Fact]
+        public async Task Sha512_Fips180_3_Async()
+        {
+            await VerifyRepeatingAsync(
+                "a",
+                1000000,
+                "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b");
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/tests/StreamHelpers.cs b/src/libraries/System.Security.Cryptography/tests/StreamHelpers.cs
new file mode 100644
index 00000000000000..022084779355c8
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography/tests/StreamHelpers.cs
@@ -0,0 +1,147 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using Test.Cryptography;
+
+namespace System.Security.Cryptography.Tests
+{
+    internal class DataRepeatingStream : Stream
+    {
+        private int _remaining;
+        private byte[] _data;
+
+        public DataRepeatingStream(string data, int repeatCount)
+        {
+            _remaining = repeatCount;
+            _data = ByteUtils.AsciiBytes(data);
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (!CanRead)
+            {
+                throw new NotSupportedException();
+            }
+
+            if (_remaining == 0)
+            {
+                return 0;
+            }
+
+            if (count < _data.Length)
+            {
+                throw new InvalidOperationException();
+            }
+
+            // For (about) half of the reads, we'll read one less byte
+            // than was asked for. This is to make sure stream readers
+            // conform to the expectation that Read MAY return less than
+            // was asked for.
+            if (count > 1 && Random.Shared.Next(2) == 0)
+            {
+                count--;
+            }
+
+            int multiple = count / _data.Length;
+
+            if (multiple > _remaining)
+            {
+                multiple = _remaining;
+            }
+
+            int localOffset = offset;
+
+            for (int i = 0; i < multiple; i++)
+            {
+                Buffer.BlockCopy(_data, 0, buffer, localOffset, _data.Length);
+                localOffset += _data.Length;
+            }
+
+            _remaining -= multiple;
+            return _data.Length * multiple;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _data = null;
+            }
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override bool CanRead { get { return _data != null; } }
+        public override bool CanSeek { get { return false; } }
+        public override bool CanWrite { get { return false; } }
+        public override long Length { get { throw new NotSupportedException(); } }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+    }
+
+    internal class UntouchableStream : Stream
+    {
+        public static Stream Instance { get; } = new UntouchableStream();
+
+        public override bool CanRead => false;
+
+        public override bool CanSeek => false;
+
+        public override bool CanWrite => false;
+
+        public override long Length => throw new NotSupportedException();
+
+        public override long Position
+        {
+            get => throw new NotSupportedException();
+            set => throw new NotSupportedException();
+        }
+
+        public override void Flush()
+        {
+            throw new NotSupportedException();
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj b/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj
index 8621f98748bd14..dafa4adb4bff23 100644
--- a/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj
+++ b/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj
@@ -265,6 +265,7 @@
     <Compile Include="Sha512ManagedTests.cs" />
     <Compile Include="SignatureDescriptionTests.cs" />
     <Compile Include="SimpleHashAlgorithmTest.cs" />
+    <Compile Include="StreamHelpers.cs" />
     <Compile Include="Sum32Hash.cs" />
     <Compile Include="SymmetricAlgorithm\Minimal.cs" />
     <Compile Include="SymmetricAlgorithm\Trivial.cs" />

From 85413211c0c915dd1a3b25b88171e2a500e24bb0 Mon Sep 17 00:00:00 2001
From: Tlakaelel Axayakatl Ceja <tlakaelel.ceja@microsoft.com>
Date: Sun, 23 Jan 2022 18:09:41 -0800
Subject: [PATCH 015/161] Title and message resources should be enforced to
 exist to prevent printing empty messages (#64151)

Sync ILLink.Shared folder with the latest version in dotnet/linker main branch

List of changes include:
- Enforce title and message resources to exist to prevent printing empty messages
- All diagnostics produced by linker now have a DiagnosticId, a title and a message
- Schema for xml link attributes file

- Added a readme file to the ILLink.Shared project to keep track of the commit is being used from dotnet/linker
---
 src/coreclr/tools/Common/Compiler/Logger.cs   |   8 +-
 .../Compiler/Logging/MessageContainer.cs      |   2 +
 .../Compiler/Dataflow/FlowAnnotations.cs      |   2 +
 .../Dataflow/ReflectionMethodBodyScanner.cs   |  16 +-
 .../Dataflow/ReflectionPatternContext.cs      |   2 +
 .../Compiler/LazyGenerics/ModuleCycleInfo.cs  |   2 +
 .../Compiler/UsageBasedMetadataManager.cs     |   1 +
 .../ILCompiler.ReadyToRun.csproj              |   1 +
 .../Compiler/RyuJitCompilation.cs             |   1 +
 .../tools/aot/ILCompiler/ILCompiler.csproj    |   8 +-
 .../tools/aot/ILLink.Shared/DiagnosticId.cs   | 156 ++-
 .../aot/ILLink.Shared/DiagnosticString.cs     |  10 +-
 .../ILLink.Shared/ILLink.LinkAttributes.xsd   | 124 +++
 .../aot/ILLink.Shared/ILLink.Shared.projitems |   8 +-
 .../aot/ILLink.Shared/MessageSubCategory.cs   |  13 +
 src/coreclr/tools/aot/ILLink.Shared/README.md |   1 +
 .../aot/ILLink.Shared/SharedStrings.resx      | 999 +++++++++++++++++-
 17 files changed, 1278 insertions(+), 76 deletions(-)
 create mode 100644 src/coreclr/tools/aot/ILLink.Shared/ILLink.LinkAttributes.xsd
 create mode 100644 src/coreclr/tools/aot/ILLink.Shared/MessageSubCategory.cs
 create mode 100644 src/coreclr/tools/aot/ILLink.Shared/README.md

diff --git a/src/coreclr/tools/Common/Compiler/Logger.cs b/src/coreclr/tools/Common/Compiler/Logger.cs
index eb77c7cd681e12..26f763b815595f 100644
--- a/src/coreclr/tools/Common/Compiler/Logger.cs
+++ b/src/coreclr/tools/Common/Compiler/Logger.cs
@@ -10,6 +10,7 @@
 using Internal.TypeSystem.Ecma;
 
 using ILCompiler.Logging;
+using ILLink.Shared;
 
 using ILSequencePoint = Internal.IL.ILSequencePoint;
 using MethodIL = Internal.IL.MethodIL;
@@ -198,11 +199,4 @@ private static string GetModuleFileName(ModuleDesc module)
             return assemblyName;
         }
     }
-
-    public static class MessageSubCategory
-    {
-        public const string None = "";
-        public const string TrimAnalysis = "Trim analysis";
-        public const string AotAnalysis = "AOT analysis";
-    }
 }
diff --git a/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs b/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs
index 95ed5bf04fa0cf..ebe08a14870ed2 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs
+++ b/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs
@@ -6,6 +6,8 @@
 using Internal.TypeSystem;
 using Internal.TypeSystem.Ecma;
 
+using ILLink.Shared;
+
 using Debug = System.Diagnostics.Debug;
 
 namespace ILCompiler.Logging
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs
index f3585e0e098f06..64ce9a5ba1218c 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs
@@ -10,6 +10,8 @@
 using Internal.TypeSystem;
 using Internal.TypeSystem.Ecma;
 
+using ILLink.Shared;
+
 using Debug = System.Diagnostics.Debug;
 
 namespace ILCompiler.Dataflow
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs
index 06d371cd17aea0..1f198fbc155e7a 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs
@@ -1029,8 +1029,8 @@ public override bool HandleCall(MethodIL callingMethodBody, MethodDesc calledMet
                                                 // We don't know what method the `MakeGenericMethod` was called on, so we have to assume
                                                 // that the method may have requirements which we can't fullfil -> warn.
                                                 reflectionContext.RecordUnrecognizedPattern(
-                                                    (int)DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed,
-                                                    new DiagnosticString(DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed).GetMessage(DiagnosticUtilities.GetMethodSignatureDisplayName(calledMethod)));
+                                                    (int)DiagnosticId.MakeGenericMethod,
+                                                    new DiagnosticString(DiagnosticId.MakeGenericMethod).GetMessage(DiagnosticUtilities.GetMethodSignatureDisplayName(calledMethod)));
                                             }
 
                                             RequireDynamicallyAccessedMembers(
@@ -1048,8 +1048,8 @@ public override bool HandleCall(MethodIL callingMethodBody, MethodDesc calledMet
                                         // We don't know what method the `MakeGenericMethod` was called on, so we have to assume
                                         // that the method may have requirements which we can't fullfil -> warn.
                                         reflectionContext.RecordUnrecognizedPattern(
-                                            (int)DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed,
-                                            new DiagnosticString(DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed).GetMessage(DiagnosticUtilities.GetMethodSignatureDisplayName(calledMethod)));
+                                            (int)DiagnosticId.MakeGenericMethod,
+                                            new DiagnosticString(DiagnosticId.MakeGenericMethod).GetMessage(DiagnosticUtilities.GetMethodSignatureDisplayName(calledMethod)));
                                     }
 
                                     RequireDynamicallyAccessedMembers(
@@ -2162,8 +2162,8 @@ public override bool HandleCall(MethodIL callingMethodBody, MethodDesc calledMet
                                     // We don't know what method the `MakeGenericMethod` was called on, so we have to assume
                                     // that the method may have requirements which we can't fullfil -> warn.
                                     reflectionContext.RecordUnrecognizedPattern(
-                                        (int)DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed,
-                                        new DiagnosticString(DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed).GetMessage(
+                                        (int)DiagnosticId.MakeGenericMethod,
+                                        new DiagnosticString(DiagnosticId.MakeGenericMethod).GetMessage(
                                             DiagnosticUtilities.GetMethodSignatureDisplayName(calledMethod)));
                                 }
                             }
@@ -3066,8 +3066,8 @@ void ValidateGenericMethodInstantiation(
             if (!AnalyzeGenericInstantiationTypeArray(genericParametersArray, ref reflectionContext, reflectionMethod, genericMethod.GetMethodDefinition().Instantiation))
             {
                 reflectionContext.RecordUnrecognizedPattern(
-                    (int)DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed,
-                    new DiagnosticString(DiagnosticId.MakeGenericMethodCannotBeStaticallyAnalyzed).GetMessage(DiagnosticUtilities.GetMethodSignatureDisplayName(reflectionMethod)));
+                    (int)DiagnosticId.MakeGenericMethod,
+                    new DiagnosticString(DiagnosticId.MakeGenericMethod).GetMessage(DiagnosticUtilities.GetMethodSignatureDisplayName(reflectionMethod)));
             }
             else
             {
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionPatternContext.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionPatternContext.cs
index 99d97784e78119..61a48fe965a0c4 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionPatternContext.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionPatternContext.cs
@@ -7,6 +7,8 @@
 using Internal.IL;
 using Internal.TypeSystem;
 
+using ILLink.Shared;
+
 namespace ILCompiler.Dataflow
 {
     /// <summary>
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs
index 378af488af0208..07e2768797cabe 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs
@@ -8,6 +8,8 @@
 using Internal.TypeSystem;
 using Internal.TypeSystem.Ecma;
 
+using ILLink.Shared;
+
 using Debug = System.Diagnostics.Debug;
 
 namespace ILCompiler
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs
index 439d4e014e6db3..971d932be8c10c 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs
@@ -15,6 +15,7 @@
 using ILCompiler.Metadata;
 using ILCompiler.DependencyAnalysis;
 using ILCompiler.DependencyAnalysisFramework;
+using ILLink.Shared;
 
 using FlowAnnotations = ILCompiler.Dataflow.FlowAnnotations;
 using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList;
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
index 5154db358a8b8e..6c7d67517a9ee1 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
@@ -283,4 +283,5 @@
     </Compile>
   </ItemGroup>
 
+  <Import Project="..\ILLink.Shared\ILLink.Shared.projitems" Label="Shared" />
 </Project>
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
index 0d8b11c51f82e2..b27f7db8ec7d8e 100644
--- a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
+++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
@@ -9,6 +9,7 @@
 
 using ILCompiler.DependencyAnalysis;
 using ILCompiler.DependencyAnalysisFramework;
+using ILLink.Shared;
 
 using Internal.IL;
 using Internal.IL.Stubs;
diff --git a/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj b/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj
index 6c559924f405c6..6c5a4a6d377d85 100644
--- a/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj
+++ b/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AssemblyName>ilc</AssemblyName>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -121,10 +121,6 @@
        On Linux renaming the library makes it difficult to debug it. -->
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Content Remove="$(RuntimeBinDir)$(LibPrefix)clrjit_$(TargetSpec)$(LibSuffix)" />
-    <Content Include="$(RuntimeBinDir)$(LibPrefix)clrjit$(LibSuffix)"
-      CopyToOutputDirectory="PreserveNewest"
-      CopyToPublishDirectory="PreserveNewest"
-      Link="$(LibPrefix)clrjit_$(TargetSpec)$(LibSuffix)"
-      />
+    <Content Include="$(RuntimeBinDir)$(LibPrefix)clrjit$(LibSuffix)" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="PreserveNewest" Link="$(LibPrefix)clrjit_$(TargetSpec)$(LibSuffix)" />
   </ItemGroup>
 </Project>
diff --git a/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs b/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs
index 8bffef3ab0e5b5..e25b16f8ef8447 100644
--- a/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs
+++ b/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs
@@ -5,17 +5,123 @@ namespace ILLink.Shared
 {
     public enum DiagnosticId
     {
+        // Linker error ids.
+        XmlFeatureDoesNotSpecifyFeatureValue = 1001,
+        XmlUnsupportedNonBooleanValueForFeature = 1002,
+        XmlException = 1003,
+        _unused_FailedToProcessDescriptorFile = 1004,
+        CouldNotFindMethodInAssembly = 1005,
+        CannotStubConstructorWhenBaseTypeDoesNotHaveConstructor = 1006,
+        CouldNotFindType = 1007,
+        CouldNotFindConstructor = 1008,
+        CouldNotFindAssemblyReference = 1009,
+        CouldNotLoadAssembly = 1010,
+        FailedToWriteOutput = 1011,
+        LinkerUnexpectedError = 1012,
+        ErrorProcessingXmlLocation = 1013,
+        XmlDocumentLocationHasInvalidFeatureDefault = 1014,
+        UnrecognizedCommandLineOption = 1015,
+        InvalidWarningVersion = 1016,
+        InvalidGenerateWarningSuppressionsValue = 1017,
+        MissingArgumentForCommanLineOptionName = 1018,
+        CustomDataFormatIsInvalid = 1019,
+        NoFilesToLinkSpecified = 1020,
+        NewMvidAndDeterministicCannotBeUsedAtSameTime = 1021,
+        AssemblyInCustomStepOptionCouldNotBeFound = 1022,
+        AssemblyPathInCustomStepMustBeFullyQualified = 1023,
+        InvalidArgForCustomStep = 1024,
+        ExpectedSignToControlNewStepInsertion = 1025,
+        PipelineStepCouldNotBeFound = 1026,
+        CustomStepTypeCouldNotBeFound = 1027,
+        CustomStepTypeIsIncompatibleWithLinkerVersion = 1028,
+        InvalidOptimizationValue = 1029,
+        InvalidArgumentForTokenOption = 1030,
+        InvalidAssemblyAction = 1031,
+        RootAssemblyCouldNotBeFound = 1032,
+        XmlDescriptorCouldNotBeFound = 1033,
+        RootAssemblyDoesNotHaveEntryPoint = 1034,
+        RootAssemblyCannotUseAction = 1035,
+        InvalidAssemblyName = 1036,
+        InvalidAssemblyRootMode = 1037,
+        ExportedTypeCannotBeResolved = 1038,
+        ReferenceAssemblyCouldNotBeLoaded = 1039,
+        FailedToResolveMetadataElement = 1040,
+        TypeUsedWithAttributeValueCouldNotBeFound = 1041,
+        CannotConverValueToType = 1042,
+        CustomAttributeArgumentForTypeRequiresNestedNode = 1043,
+        CouldNotResolveCustomAttributeTypeValue = 1044,
+        UnexpectedAttributeArgumentType = 1045,
+        InvalidMetadataOption = 1046,
+
         // Linker diagnostic ids.
+        TypeHasNoFieldsToPreserve = 2001,
+        TypeHasNoMethodsToPreserve = 2002,
+        CouldNotResolveDependencyAssembly = 2003,
+        CouldNotResolveDependencyType = 2004,
+        CouldNotResolveDependencyMember = 2005,
+        _unused_UnrecognizedReflectionPattern = 2006,
+        XmlCouldNotResolveAssembly = 2007,
+        XmlCouldNotResolveType = 2008,
+        XmlCouldNotFindMethodOnType = 2009,
+        XmlInvalidValueForStub = 2010,
+        XmlUnkownBodyModification = 2011,
+        XmlCouldNotFindFieldOnType = 2012,
+        XmlSubstitutedFieldNeedsToBeStatic = 2013,
+        XmlMissingSubstitutionValueForField = 2014,
+        XmlInvalidSubstitutionValueForField = 2015,
+        XmlCouldNotFindEventOnType = 2016,
+        XmlCouldNotFindPropertyOnType = 2017,
+        XmlCouldNotFindGetAccesorOfPropertyOnType = 2018,
+        XmlCouldNotFindSetAccesorOfPropertyOnType = 2019,
+        _unused_RearrangedXmlWarning1 = 2020,
+        _unused_RearrangedXmlWarning2 = 2021,
+        XmlCouldNotFindMatchingConstructorForCustomAttribute = 2022,
+        XmlMoreThanOneReturnElementForMethod = 2023,
+        XmlMoreThanOneValyForParameterOfMethod = 2024,
+        XmlDuplicatePreserveMember = 2025,
         RequiresUnreferencedCode = 2026,
+        AttributeShouldOnlyBeUsedOnceOnMember = 2027,
+        AttributeDoesntHaveTheRequiredNumberOfParameters = 2028,
+        XmlElementDoesNotContainRequiredAttributeFullname = 2029,
+        XmlCouldNotResolveAssemblyForAttribute = 2030,
+        XmlAttributeTypeCouldNotBeFound = 2031,
+        UnrecognizedParameterInMethodCreateInstance = 2032,
+        DeprecatedPreserveDependencyAttribute = 2033,
+        DynamicDependencyAttributeCouldNotBeAnalyzed = 2034,
+        UnresolvedAssemblyInDynamicDependencyAttribute = 2035,
+        UnresolvedTypeInDynamicDependencyAttribute = 2036,
+        NoMembersResolvedForMemberSignatureOrType = 2037,
+        XmlMissingNameAttributeInResource = 2038,
+        XmlInvalidValueForAttributeActionForResource = 2039,
+        XmlCouldNotFindResourceToRemoveInAssembly = 2040,
+        DynamicallyAccessedMembersIsNotAllowedOnMethods = 2041,
+        DynamicallyAccessedMembersCouldNotFindBackingField = 2042,
+        DynamicallyAccessedMembersConflictsBetweenPropertyAndAccessor = 2043,
+        XmlCouldNotFindAnyTypeInNamespace = 2044,
+        AttributeIsReferencedButTrimmerRemoveAllInstances = 2045,
         RequiresUnreferencedCodeAttributeMismatch = 2046,
+        _unused_DynamicallyAccessedMembersMismatchBetweenOverrides = 2047,
+        XmlRemoveAttributeInstancesCanOnlyBeUsedOnType = 2048,
+        _unused_UnrecognizedInternalAttribute = 2049,
         CorrectnessOfCOMCannotBeGuaranteed = 2050,
+        XmlPropertyDoesNotContainAttributeName = 2051,
+        XmlCouldNotFindProperty = 2052,
+        _unused_XmlInvalidPropertyValueForProperty = 2053,
+        _unused_XmlInvalidArgumentForParameterOfType = 2054,
         MakeGenericType = 2055,
+        DynamicallyAccessedMembersOnPropertyConflictsWithBackingField = 2056,
+        UnrecognizedTypeNameInTypeGetType = 2057,
+        ParametersOfAssemblyCreateInstanceCannotBeAnalyzed = 2058,
+        UnrecognizedTypeInRuntimeHelpersRunClassConstructor = 2059,
         MakeGenericMethod = 2060,
-        RequiresOnBaseClass = 2109,
-        RequiresUnreferencedCodeOnStaticConstructor = 2116,
+        UnresolvedAssemblyInCreateInstance = 2061,
+        MethodParameterCannotBeStaticallyDetermined = 2062,
+        MethodReturnValueCannotBeStaticallyDetermined = 2063,
+        FieldValueCannotBeStaticallyDetermined = 2064,
+        ImplicitThisCannotBeStaticallyDetermined = 2065,
+        TypePassedToGenericParameterCannotBeStaticallyDetermined = 2066,
 
         // Dynamically Accessed Members attribute mismatch.
-        MakeGenericMethodCannotBeStaticallyAnalyzed = 2060,
         DynamicallyAccessedMembersMismatchParameterTargetsParameter = 2067,
         DynamicallyAccessedMembersMismatchParameterTargetsMethodReturnType = 2068,
         DynamicallyAccessedMembersMismatchParameterTargetsField = 2069,
@@ -41,7 +147,32 @@ public enum DiagnosticId
         DynamicallyAccessedMembersMismatchTypeArgumentTargetsField = 2089,
         DynamicallyAccessedMembersMismatchTypeArgumentTargetsThisParameter = 2090,
         DynamicallyAccessedMembersMismatchTypeArgumentTargetsGenericParameter = 2091,
+        DynamicallyAccessedMembersMismatchOnMethodParameterBetweenOverrides = 2092,
+        DynamicallyAccessedMembersMismatchOnMethodReturnValueBetweenOverrides = 2093,
+        DynamicallyAccessedMembersMismatchOnImplicitThisBetweenOverrides = 2094,
+        DynamicallyAccessedMembersMismatchOnGenericParameterBetweenOverrides = 2095,
+
+        CaseInsensitiveTypeGetTypeCallIsNotSupported = 2096,
+        DynamicallyAccessedMembersOnFieldCanOnlyApplyToTypesOrStrings = 2097,
+        DynamicallyAccessedMembersOnMethodParameterCanOnlyApplyToTypesOrStrings = 2098,
+        DynamicallyAccessedMembersOnPropertyCanOnlyApplyToTypesOrStrings = 2099,
+        XmlUnsuportedWildcard = 2100,
+        AssemblyWithEmbeddedXmlApplyToAnotherAssembly = 2101,
+        InvalidIsTrimmableValue = 2102,
         PropertyAccessorParameterInLinqExpressionsCannotBeStaticallyDetermined = 2103,
+        AssemblyProducedTrimWarnings = 2104,
+        TypeWasNotFoundInAssemblyNorBaseLibrary = 2105,
+        DynamicallyAccessedMembersOnMethodReturnValueCanOnlyApplyToTypesOrStrings = 2106,
+        MethodsAreAssociatedWithStateMachine = 2107,
+        InvalidScopeInUnconditionalSuppressMessage = 2108,
+        RequiresUnreferencedCodeOnBaseClass = 2109,
+        DynamicallyAccessedMembersFieldAccessedViaReflection = 2110,
+        DynamicallyAccessedMembersMethodAccessedViaReflection = 2111,
+        DynamicallyAccessedMembersOnTypeReferencesMemberWithRequiresUnreferencedCode = 2112,
+        DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithRequiresUnreferencedCode = 2113,
+        DynamicallyAccessedMembersOnTypeReferencesMemberWithDynamicallyAccessedMembers = 2114,
+        DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithDynamicallyAccessedMembers = 2115,
+        RequiresUnreferencedCodeOnStaticConstructor = 2116,
 
         // Single-file diagnostic ids.
         AvoidAssemblyLocationInSingleFile = 3000,
@@ -62,5 +193,24 @@ public enum DiagnosticId
     public static class DiagnosticIdExtensions
     {
         public static string AsString(this DiagnosticId diagnosticId) => $"IL{(int)diagnosticId}";
+
+        public static string GetDiagnosticSubcategory(this DiagnosticId diagnosticId) =>
+            (int)diagnosticId switch
+            {
+                2026 => MessageSubCategory.TrimAnalysis,
+                2032 => MessageSubCategory.TrimAnalysis,
+                2041 => MessageSubCategory.TrimAnalysis,
+                2042 => MessageSubCategory.TrimAnalysis,
+                2043 => MessageSubCategory.TrimAnalysis,
+                2045 => MessageSubCategory.TrimAnalysis,
+                2046 => MessageSubCategory.TrimAnalysis,
+                2050 => MessageSubCategory.TrimAnalysis,
+                var x when x >= 2055 && x <= 2099 => MessageSubCategory.TrimAnalysis,
+                2103 => MessageSubCategory.TrimAnalysis,
+                2106 => MessageSubCategory.TrimAnalysis,
+                2107 => MessageSubCategory.TrimAnalysis,
+                var x when x >= 2109 && x <= 2116 => MessageSubCategory.TrimAnalysis,
+                _ => MessageSubCategory.None,
+            };
     }
 }
diff --git a/src/coreclr/tools/aot/ILLink.Shared/DiagnosticString.cs b/src/coreclr/tools/aot/ILLink.Shared/DiagnosticString.cs
index 103b93ed28bb01..f14b58b0600830 100644
--- a/src/coreclr/tools/aot/ILLink.Shared/DiagnosticString.cs
+++ b/src/coreclr/tools/aot/ILLink.Shared/DiagnosticString.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+
 namespace ILLink.Shared
 {
     public readonly struct DiagnosticString
@@ -11,15 +13,15 @@ public readonly struct DiagnosticString
         public DiagnosticString(DiagnosticId diagnosticId)
         {
             var resourceManager = SharedStrings.ResourceManager;
-            _titleFormat = resourceManager.GetString($"{diagnosticId}Title") ?? string.Empty;
-            _messageFormat = resourceManager.GetString($"{diagnosticId}Message") ?? string.Empty;
+            _titleFormat = resourceManager.GetString($"{diagnosticId}Title") ?? throw new InvalidOperationException($"{diagnosticId} does not have a matching resource called {diagnosticId}Title");
+            _messageFormat = resourceManager.GetString($"{diagnosticId}Message") ?? throw new InvalidOperationException($"{diagnosticId} does not have a matching resource called {diagnosticId}Message");
         }
 
         public DiagnosticString(string diagnosticResourceStringName)
         {
             var resourceManager = SharedStrings.ResourceManager;
-            _titleFormat = resourceManager.GetString($"{diagnosticResourceStringName}Title") ?? string.Empty;
-            _messageFormat = resourceManager.GetString($"{diagnosticResourceStringName}Message") ?? string.Empty;
+            _titleFormat = resourceManager.GetString($"{diagnosticResourceStringName}Title") ?? throw new InvalidOperationException($"{diagnosticResourceStringName} does not have a matching resource called {diagnosticResourceStringName}Title");
+            _messageFormat = resourceManager.GetString($"{diagnosticResourceStringName}Message") ?? throw new InvalidOperationException($"{diagnosticResourceStringName} does not have a matching resource called {diagnosticResourceStringName}Message");
         }
 
         public string GetMessage(params string[] args) =>
diff --git a/src/coreclr/tools/aot/ILLink.Shared/ILLink.LinkAttributes.xsd b/src/coreclr/tools/aot/ILLink.Shared/ILLink.LinkAttributes.xsd
new file mode 100644
index 00000000000000..f1156b0a4d6902
--- /dev/null
+++ b/src/coreclr/tools/aot/ILLink.Shared/ILLink.LinkAttributes.xsd
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xsd:schema attributeFormDefault="unqualified"
+		elementFormDefault="unqualified"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+
+    <xsd:complexType name="membertype">
+        <xsd:choice maxOccurs="unbounded" minOccurs="0">
+            <xsd:element name="attribute" type="attribute" />
+        </xsd:choice>
+        <xsd:attribute name="feature" />
+        <xsd:attribute name="featurevalue" type="xsd:boolean" />
+        <xsd:attribute name="featuredefault" type="xsd:boolean" />
+        <xsd:attribute name="name" />
+        <xsd:attribute name="signature" />
+    </xsd:complexType>
+
+    <xsd:complexType name="method">
+        <xsd:complexContent>
+            <xsd:extension base="membertype">
+                <xsd:choice maxOccurs="unbounded" minOccurs="0">
+                    <xsd:choice maxOccurs="unbounded" minOccurs="0">
+                        <xsd:element name="parameter">
+                            <xsd:complexType>
+                                <xsd:choice maxOccurs="unbounded" minOccurs="0">
+                                    <xsd:element name="attribute" type="attribute" />
+                                </xsd:choice>
+                                <xsd:attribute name="name" use="required" />
+                            </xsd:complexType>
+                        </xsd:element>
+                    </xsd:choice>
+                    <xsd:choice maxOccurs="1" minOccurs="0">
+                        <xsd:element name="return">
+                            <xsd:complexType>
+                                <xsd:choice maxOccurs="unbounded" minOccurs="0">
+                                    <xsd:element name="attribute" type="attribute" />
+                                </xsd:choice>
+                            </xsd:complexType>
+                        </xsd:element>
+                    </xsd:choice>
+                </xsd:choice>
+            </xsd:extension>
+        </xsd:complexContent>
+    </xsd:complexType>
+
+    <xsd:complexType name="argument" mixed="true">
+        <xsd:choice minOccurs="0" maxOccurs="1">
+            <xsd:element name="argument">
+                <xsd:complexType>
+                    <xsd:simpleContent>
+                        <xsd:extension base="xsd:string">
+                            <xsd:attribute name="type" />
+                        </xsd:extension>
+                    </xsd:simpleContent>
+                </xsd:complexType>
+            </xsd:element>
+        </xsd:choice>
+        <xsd:attribute name="type" />
+    </xsd:complexType>
+
+    <xsd:complexType name="attribute">
+        <xsd:choice maxOccurs="unbounded" minOccurs="0">
+            <xsd:element name="argument" type="argument" />
+            <xsd:element name="property">
+                <xsd:complexType mixed="true">
+                    <xsd:attribute name="name" use="required" />
+                </xsd:complexType>
+            </xsd:element>
+        </xsd:choice>
+        <xsd:attribute name="internal" />
+        <xsd:attribute name="fullname" />
+        <xsd:attribute name="assembly" />
+    </xsd:complexType>
+
+    <xsd:complexType name="assembly">
+        <xsd:choice maxOccurs="unbounded" minOccurs="0">
+            <xsd:element name="attribute" type="attribute" />
+            <xsd:element name="type" type="type" />
+        </xsd:choice>
+        <xsd:attribute name="fullname" use="required" />
+        <xsd:attribute name="feature" />
+        <xsd:attribute name="featurevalue" type="xsd:boolean" />
+        <xsd:attribute name="featuredefault" type="xsd:boolean" />
+    </xsd:complexType>
+
+    <xsd:complexType name ="nestedtype">
+        <xsd:choice minOccurs="0" maxOccurs="unbounded">
+            <xsd:element name="event" type="membertype" />
+            <xsd:element name="method" type="method" />
+            <xsd:element name="field" type="membertype" />
+            <xsd:element name="property" type="membertype" />
+            <xsd:element name="attribute" type="attribute" />
+            <xsd:element name="type" type="nestedtype" />
+        </xsd:choice>
+        <xsd:attribute name="name" use="required"/>
+        <xsd:attribute name="feature" />
+        <xsd:attribute name="featurevalue" type="xsd:boolean" />
+        <xsd:attribute name="featuredefault" type="xsd:boolean" />
+    </xsd:complexType>
+
+    <xsd:complexType name="type">
+        <xsd:choice maxOccurs="unbounded" minOccurs="0">
+            <xsd:element name="attribute" type="attribute" />
+            <xsd:element name="event" type="membertype" />
+            <xsd:element name="method" type="method" />
+            <xsd:element name="field" type="membertype" />
+            <xsd:element name="property" type="membertype" />
+            <xsd:element name="type" type="nestedtype"/>
+        </xsd:choice>
+        <xsd:attribute name="feature" />
+        <xsd:attribute name="featurevalue" type="xsd:boolean" />
+        <xsd:attribute name="featuredefault" type="xsd:boolean" />
+        <xsd:attribute name="fullname" use="required"/>
+    </xsd:complexType>
+
+    <xsd:element name="linker">
+        <xsd:complexType>
+            <xsd:choice maxOccurs="unbounded" minOccurs="0">
+                <xsd:element name="assembly" type="assembly" />
+                <xsd:element name="type" type="type" />
+            </xsd:choice>
+        </xsd:complexType>
+    </xsd:element>
+
+</xsd:schema>
diff --git a/src/coreclr/tools/aot/ILLink.Shared/ILLink.Shared.projitems b/src/coreclr/tools/aot/ILLink.Shared/ILLink.Shared.projitems
index 0a61390d8d025e..ffbfab3b98417f 100644
--- a/src/coreclr/tools/aot/ILLink.Shared/ILLink.Shared.projitems
+++ b/src/coreclr/tools/aot/ILLink.Shared/ILLink.Shared.projitems
@@ -13,6 +13,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)DiagnosticId.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DiagnosticString.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)MessageFormat.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)MessageSubCategory.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="$(MSBuildThisFileDirectory)SharedStrings.resx">
@@ -21,4 +22,9 @@
       <SubType>Designer</SubType>
     </EmbeddedResource>
   </ItemGroup>
-</Project>
\ No newline at end of file
+  <ItemGroup>
+     <None Include="$(MSBuildThisFileDirectory)ILLink.LinkAttributes.xsd">
+       <SubType>Designer</SubType>
+     </None>
+   </ItemGroup>
+</Project>
diff --git a/src/coreclr/tools/aot/ILLink.Shared/MessageSubCategory.cs b/src/coreclr/tools/aot/ILLink.Shared/MessageSubCategory.cs
new file mode 100644
index 00000000000000..92c1077b14baf3
--- /dev/null
+++ b/src/coreclr/tools/aot/ILLink.Shared/MessageSubCategory.cs
@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace ILLink.Shared
+{
+    public static class MessageSubCategory
+    {
+        public const string None = "";
+        public const string TrimAnalysis = "Trim analysis";
+        public const string UnresolvedAssembly = "Unresolved assembly";
+        public const string AotAnalysis = "AOT analysis";
+    }
+}
diff --git a/src/coreclr/tools/aot/ILLink.Shared/README.md b/src/coreclr/tools/aot/ILLink.Shared/README.md
new file mode 100644
index 00000000000000..229b67e492bf0b
--- /dev/null
+++ b/src/coreclr/tools/aot/ILLink.Shared/README.md
@@ -0,0 +1 @@
+Sources taken from https://github.com/dotnet/linker/tree/890591b13da936d2c38a52afdaeac0db69858d4f/src/ILLink.Shared.
diff --git a/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx b/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx
index 0d53dff7e254e0..e2db35e7073313 100644
--- a/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx
+++ b/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx
@@ -53,7 +53,6 @@
     value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
             : and then encoded with base64 encoding.
-
     mimetype: application/x-microsoft.net.object.bytearray.base64
     value   : The object must be serialized into a byte array 
             : using a System.ComponentModel.TypeConverter
@@ -117,12 +116,954 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="XmlFeatureDoesNotSpecifyFeatureValueTitle" xml:space="preserve">
+    <value>An Xml Feature does not specify a 'featurevalue' attribute.</value>
+  </data>
+  <data name="XmlFeatureDoesNotSpecifyFeatureValueMessage" xml:space="preserve">
+    <value>Failed to process '{0}'. Feature '{1}' does not specify a 'featurevalue' attribute.</value>
+  </data>
+  <data name="XmlUnsupportedNonBooleanValueForFeatureTitle" xml:space="preserve">
+    <value>Feature definition has to be a boolean.</value>
+  </data>
+  <data name="XmlUnsupportedNonBooleanValueForFeatureMessage" xml:space="preserve">
+    <value>Failed to process '{0}'. Unsupported non-boolean feature definition '{1}'.</value>
+  </data>
+  <data name="XmlExceptionTitle" xml:space="preserve">
+    <value>An exception was thrown while processing the xml file.</value>
+  </data>
+  <data name="XmlExceptionMessage" xml:space="preserve">
+    <value>Error processing '{0}': {1}.</value>
+  </data>
+  <data name="CouldNotFindMethodInAssemblyTitle" xml:space="preserve">
+    <value>An error ocurred while processing a method in assembly.</value>
+  </data>
+  <data name="CouldNotFindMethodInAssemblyMessage" xml:space="preserve">
+    <value>Error processing method '{0}' in assembly '{1}'.</value>
+  </data>
+  <data name="CannotStubConstructorWhenBaseTypeDoesNotHaveConstructorTitle" xml:space="preserve">
+    <value>Cannot stub constructor of a type when base type does not have default constructor. Constructors of derived types marked for substitution require to have a default constructor in its base type.</value>
+  </data>
+  <data name="CannotStubConstructorWhenBaseTypeDoesNotHaveConstructorMessage" xml:space="preserve">
+    <value>Cannot stub constructor on '{0}' when base type does not have default constructor.</value>
+  </data>
+  <data name="CouldNotFindTypeTitle" xml:space="preserve">
+    <value>Could not find predefined type".</value>
+  </data>
+  <data name="CouldNotFindTypeMessage" xml:space="preserve">
+    <value>Missing predefined '{0}' type".</value>
+  </data>
+  <data name="CouldNotFindConstructorTitle" xml:space="preserve">
+    <value>Could not find constructor.</value>
+  </data>
+  <data name="CouldNotFindConstructorMessage" xml:space="preserve">
+    <value>Could not find constructor on '{0}'.</value>
+  </data>
+  <data name="CouldNotFindAssemblyReferenceTitle" xml:space="preserve">
+    <value>Assembly reference could not be resolved.</value>
+  </data>
+  <data name="CouldNotFindAssemblyReferenceMessage" xml:space="preserve">
+    <value>Assembly reference '{0}' could not be resolved.</value>
+  </data>
+  <data name="CouldNotLoadAssemblyTitle" xml:space="preserve">
+    <value>Assembly cannot be loaded due to failure in processing the reference assembly.</value>
+  </data>
+  <data name="CouldNotLoadAssemblyMessage" xml:space="preserve">
+    <value>Assembly '{0}' cannot be loaded due to failure in processing '{1}' reference</value>
+  </data>
+  <data name="FailedToWriteOutputTitle" xml:space="preserve">
+    <value>There was an error writing the linked assembly 'output'.</value>
+  </data>
+  <data name="FailedToWriteOutputMessage" xml:space="preserve">
+    <value>Failed to write '{0}'.</value>
+  </data>
+  <data name="LinkerUnexpectedErrorTitle" xml:space="preserve">
+    <value>There was an unexpected error while trimming. An exception with more details is printed to the MSBuild log. Please share this stack trace with the IL Linker team to further investigate the cause and possible solution.</value>
+  </data>
+  <data name="LinkerUnexpectedErrorMessage" xml:space="preserve">
+    <value>IL Trimmer has encountered an unexpected error. Please report the issue at https://github.com/dotnet/linker/issues</value>
+  </data>
+  <data name="ErrorProcessingXmlLocationTitle" xml:space="preserve">
+    <value>There was an error processing 'XML document location' xml file. The most likely reason for this is that the XML file has syntactical errors.</value>
+  </data>
+  <data name="ErrorProcessingXmlLocationMessage" xml:space="preserve">
+    <value>Error processing '{0}'.</value>
+  </data>
+  <data name="XmlDocumentLocationHasInvalidFeatureDefaultTitle" xml:space="preserve">
+    <value>Element in XML document contains a 'featuredefault' attribute with an invalid value.</value>
+  </data>
+  <data name="XmlDocumentLocationHasInvalidFeatureDefaultMessage" xml:space="preserve">
+    <value>Failed to process '{0}'. Unsupported value for featuredefault attribute.</value>
+  </data>
+  <data name="UnrecognizedCommandLineOptionTitle" xml:space="preserve">
+    <value>The string passed to the command-line does not correspond to a valid command-line option.</value>
+  </data>
+  <data name="UnrecognizedCommandLineOptionMessage" xml:space="preserve">
+    <value>Unrecognized command-line option: '{0}'.</value>
+  </data>
+  <data name="InvalidWarningVersionTitle" xml:space="preserve">
+    <value>The value given for the --warn argument was not a valid warning version.</value>
+  </data>
+  <data name="InvalidWarningVersionMessage" xml:space="preserve">
+    <value>Invalid warning version '{0}'.</value>
+  </data>
+  <data name="InvalidGenerateWarningSuppressionsValueTitle" xml:space="preserve">
+    <value>Invalid value 'value' was used for command-line option '--generate-warning-suppressions'; must be 'cs' or 'xml'.</value>
+  </data>
+  <data name="InvalidGenerateWarningSuppressionsValueMessage" xml:space="preserve">
+    <value>Invalid value '{0}' for '--generate-warning-suppressions' option.</value>
+  </data>
+  <data name="MissingArgumentForCommanLineOptionNameTitle" xml:space="preserve">
+    <value>The command-line option 'optionName' was specified but no argument was given.</value>
+  </data>
+  <data name="MissingArgumentForCommanLineOptionNameMessage" xml:space="preserve">
+    <value>Missing argument for '{0}' option.</value>
+  </data>
+  <data name="CustomDataFormatIsInvalidTitle" xml:space="preserve">
+    <value>The command-line option --custom-data receives a key-value pair using the format KEY=VALUE.</value>
+  </data>
+  <data name="CustomDataFormatIsInvalidMessage" xml:space="preserve">
+    <value>Value used with '--custom-data' has to be in the KEY=VALUE format.</value>
+  </data>
+  <data name="NoFilesToLinkSpecifiedTitle" xml:space="preserve">
+    <value>No input files were specified. Use one of the resolver options.</value>
+  </data>
+  <data name="NoFilesToLinkSpecifiedMessage" xml:space="preserve">
+    <value>No input files were specified. Use one of '{0}' options.</value>
+  </data>
+  <data name="NewMvidAndDeterministicCannotBeUsedAtSameTimeTitle" xml:space="preserve">
+    <value>Options '--new-mvid' and '--deterministic' cannot be used at the same time.</value>
+  </data>
+  <data name="NewMvidAndDeterministicCannotBeUsedAtSameTimeMessage" xml:space="preserve">
+    <value>Options '--new-mvid' and '--deterministic' cannot be used at the same time.</value>
+  </data>
+  <data name="AssemblyInCustomStepOptionCouldNotBeFoundTitle" xml:space="preserve">
+    <value>The assembly argument specified for '--custom-step' option could not be found.</value>
+  </data>
+  <data name="AssemblyInCustomStepOptionCouldNotBeFoundMessage" xml:space="preserve">
+    <value>The assembly '{0}' specified for '--custom-step' option could not be found.</value>
+  </data>
+  <data name="AssemblyPathInCustomStepMustBeFullyQualifiedTitle" xml:space="preserve">
+    <value>The path to the assembly specified for '--custom-step' must be fully qualified.</value>
+  </data>
+  <data name="AssemblyPathInCustomStepMustBeFullyQualifiedMessage" xml:space="preserve">
+    <value>The path to the assembly '{0}' specified for '--custom-step' must be fully qualified.</value>
+  </data>
+  <data name="InvalidArgForCustomStepTitle" xml:space="preserve">
+    <value>An invalid value was specified for '--custom-step' option.</value>
+  </data>
+  <data name="InvalidArgForCustomStepMessage" xml:space="preserve">
+    <value>Invalid value '{0}' specified for '--custom-step' option.</value>
+  </data>
+  <data name="ExpectedSignToControlNewStepInsertionTitle" xml:space="preserve">
+    <value>A custom step that is inserted relative to an existing step in the pipeline must specify whether to be added before (-) or after (+) the step it's relative to.</value>
+  </data>
+  <data name="ExpectedSignToControlNewStepInsertionMessage" xml:space="preserve">
+    <value>Expected '+' or '-' to control new step insertion.</value>
+  </data>
+  <data name="PipelineStepCouldNotBeFoundTitle" xml:space="preserve">
+    <value>A custom step was specified for insertion relative to a non existent step.</value>
+  </data>
+  <data name="PipelineStepCouldNotBeFoundMessage" xml:space="preserve">
+    <value>Pipeline step '{0}' could not be found.</value>
+  </data>
+  <data name="CustomStepTypeCouldNotBeFoundTitle" xml:space="preserve">
+    <value>The custom step could not be found in the given assembly.</value>
+  </data>
+  <data name="CustomStepTypeCouldNotBeFoundMessage" xml:space="preserve">
+    <value>Custom step '{0}' could not be found.</value>
+  </data>
+  <data name="CustomStepTypeIsIncompatibleWithLinkerVersionTitle" xml:space="preserve">
+    <value>Custom step is incompatible with this trimmer version.</value>
+  </data>
+  <data name="CustomStepTypeIsIncompatibleWithLinkerVersionMessage" xml:space="preserve">
+    <value>Custom step '{0}' is incompatible with this trimmer version.</value>
+  </data>
+  <data name="InvalidOptimizationValueTitle" xml:space="preserve">
+    <value>The optimization 'text' is invalid. Optimization values can either be 'beforefieldinit', 'overrideremoval', 'unreachablebodies', 'unusedinterfaces', 'ipconstprop', or 'sealer'.</value>
+  </data>
+  <data name="InvalidOptimizationValueMessage" xml:space="preserve">
+    <value>Invalid optimization value '{0}'.</value>
+  </data>
+  <data name="InvalidArgumentForTokenOptionTitle" xml:space="preserve">
+    <value>Invalid argument for 'token' option.</value>
+  </data>
+  <data name="InvalidArgumentForTokenOptionMessage" xml:space="preserve">
+    <value>Invalid argument for '{0}' option.</value>
+  </data>
+  <data name="InvalidAssemblyActionTitle" xml:space="preserve">
+    <value>Invalid assembly action.</value>
+  </data>
+  <data name="InvalidAssemblyActionMessage" xml:space="preserve">
+    <value>Invalid assembly action '{0}'.</value>
+  </data>
+  <data name="RootAssemblyCouldNotBeFoundTitle" xml:space="preserve">
+    <value>Root assembly could not be found.</value>
+  </data>
+  <data name="RootAssemblyCouldNotBeFoundMessage" xml:space="preserve">
+    <value>Root assembly '{0}' could not be found.</value>
+  </data>
+  <data name="XmlDescriptorCouldNotBeFoundTitle" xml:space="preserve">
+    <value>XML descriptor file could not be found'.</value>
+  </data>
+  <data name="XmlDescriptorCouldNotBeFoundMessage" xml:space="preserve">
+    <value>XML descriptor file '{0}' could not be found'.</value>
+  </data>
+  <data name="RootAssemblyDoesNotHaveEntryPointTitle" xml:space="preserve">
+    <value>Root assembly does not have entry point.</value>
+  </data>
+  <data name="RootAssemblyDoesNotHaveEntryPointMessage" xml:space="preserve">
+    <value>Root assembly '{0}' does not have entry point.</value>
+  </data>
+  <data name="RootAssemblyCannotUseActionTitle" xml:space="preserve">
+    <value>Referenced root assembly cannot use the specified action.</value>
+  </data>
+  <data name="RootAssemblyCannotUseActionMessage" xml:space="preserve">
+    <value>Root assembly '{0}' cannot use action '{1}'.</value>
+  </data>
+  <data name="InvalidAssemblyNameTitle" xml:space="preserve">
+    <value>Invalid assembly name.</value>
+  </data>
+  <data name="InvalidAssemblyNameMessage" xml:space="preserve">
+    <value>Invalid assembly name '{0}'.</value>
+  </data>
+  <data name="InvalidAssemblyRootModeTitle" xml:space="preserve">
+    <value>Invalid assembly root mode.</value>
+  </data>
+  <data name="InvalidAssemblyRootModeMessage" xml:space="preserve">
+    <value>Invalid assembly root mode '{0}'.</value>
+  </data>
+  <data name="ExportedTypeCannotBeResolvedTitle" xml:space="preserve">
+    <value>Exported type cannot be resolved.</value>
+  </data>
+  <data name="ExportedTypeCannotBeResolvedMessage" xml:space="preserve">
+    <value>Exported type '{0}' cannot be resolved.</value>
+  </data>
+  <data name="ReferenceAssemblyCouldNotBeLoadedTitle" xml:space="preserve">
+    <value>A reference assembly input passed via -reference could not be loaded.</value>
+  </data>
+  <data name="ReferenceAssemblyCouldNotBeLoadedMessage" xml:space="preserve">
+    <value>Reference assembly '{0}' could not be loaded.</value>
+  </data>
+  <data name="FailedToResolveMetadataElementTitle" xml:space="preserve">
+    <value>Metadata element cannot be resolved. This usually means there is a version mismatch between dependencies.</value>
+  </data>
+  <data name="FailedToResolveMetadataElementMessage" xml:space="preserve">
+    <value>{0}.</value>
+  </data>
+  <data name="FailedToResolveFieldElementTitle" xml:space="preserve">
+    <value>Field element cannot be resolved. This usually means there is a version mismatch between dependencies.</value>
+  </data>
+  <data name="FailedToResolveFieldElementMessage" xml:space="preserve">
+    <value>Field '{0}' reference could not be resolved.</value>
+  </data>
+  <data name="FailedToResolveMethodElementTitle" xml:space="preserve">
+    <value>Method element cannot be resolved. This usually means there is a version mismatch between dependencies.</value>
+  </data>
+  <data name="FailedToResolveMethodElementMessage" xml:space="preserve">
+    <value>Method '{0}' reference could not be resolved.</value>
+  </data>
+  <data name="FailedToResolveTypeElementTitle" xml:space="preserve">
+    <value>Type element cannot be resolved. This usually means there is a version mismatch between dependencies.</value>
+  </data>
+  <data name="FailedToResolveTypeElementMessage" xml:space="preserve">
+    <value>Type '{0}' reference could not be resolved.</value>
+  </data>
+  <data name="TypeUsedWithAttributeValueCouldNotBeFoundTitle" xml:space="preserve">
+    <value>The type name used to define custom attribute value could not be resolved.</value>
+  </data>
+  <data name="TypeUsedWithAttributeValueCouldNotBeFoundMessage" xml:space="preserve">
+    <value>The type '{0}' used with attribute value '{1}' could not be found.</value>
+  </data>
+  <data name="CannotConverValueToTypeTitle" xml:space="preserve">
+    <value>The 'value' specified for the custom attribute value cannot be converted to specified argument type 'typeName'.</value>
+  </data>
+  <data name="CannotConverValueToTypeMessage" xml:space="preserve">
+    <value>Cannot convert value '{0}' to type '{1}'.</value>
+  </data>
+  <data name="CustomAttributeArgumentForTypeRequiresNestedNodeTitle" xml:space="preserve">
+    <value>The syntax for custom attribute value for 'type' requires to also specify the underlying attribute type.</value>
+  </data>
+  <data name="CustomAttributeArgumentForTypeRequiresNestedNodeMessage" xml:space="preserve">
+    <value>Custom attribute argument for '{0}' requires nested '{1}' node.</value>
+  </data>
+  <data name="CouldNotResolveCustomAttributeTypeValueTitle" xml:space="preserve">
+    <value>The value specified for the custom attribute of System.Type type could not be resolved.</value>
+  </data>
+  <data name="CouldNotResolveCustomAttributeTypeValueMessage" xml:space="preserve">
+    <value>Could not resolve custom attribute type value '{0}'.</value>
+  </data>
+  <data name="UnexpectedAttributeArgumentTypeTitle" xml:space="preserve">
+    <value>The type name used with attribute type is not one of the supported types.</value>
+  </data>
+  <data name="UnexpectedAttributeArgumentTypeMessage" xml:space="preserve">
+    <value>Unexpected attribute argument type '{0}'.</value>
+  </data>
+  <data name="InvalidMetadataOptionTitle" xml:space="preserve">
+    <value>Invalid metadata value.</value>
+  </data>
+  <data name="InvalidMetadataOptionMessage" xml:space="preserve">
+    <value>Invalid metadata value '{0}'.</value>
+  </data>
+  <data name="TypeHasNoFieldsToPreserveTitle" xml:space="preserve">
+    <value>The XML descriptor preserves fields on type, but this type has no fields.</value>
+  </data>
+  <data name="TypeHasNoFieldsToPreserveMessage" xml:space="preserve">
+    <value>Type '{0}' has no fields to preserve.</value>
+  </data>
+  <data name="TypeHasNoMethodsToPreserveTitle" xml:space="preserve">
+    <value>The XML descriptor preserves methods on type, but this type has no methods.</value>
+  </data>
+  <data name="TypeHasNoMethodsToPreserveMessage" xml:space="preserve">
+    <value>Type '{0}' has no methods to preserve.</value>
+  </data>
+  <data name="CouldNotResolveDependencyAssemblyTitle" xml:space="preserve">
+    <value>The assembly in PreserveDependency attribute could not be resolved.</value>
+  </data>
+  <data name="CouldNotResolveDependencyAssemblyMessage" xml:space="preserve">
+    <value>Could not resolve dependency assembly '{0}' specified in a 'PreserveDependency' attribute.</value>
+  </data>
+  <data name="CouldNotResolveDependencyTypeTitle" xml:space="preserve">
+    <value>The type in PreserveDependency attribute could not be resolved.</value>
+  </data>
+  <data name="CouldNotResolveDependencyTypeMessage" xml:space="preserve">
+    <value>Could not resolve dependency type '{0}' specified in a 'PreserveDependency' attribute.</value>
+  </data>
+  <data name="CouldNotResolveDependencyMemberTitle" xml:space="preserve">
+    <value>The member in PreserveDependency attribute could not be resolved.</value>
+  </data>
+  <data name="CouldNotResolveDependencyMemberMessage" xml:space="preserve">
+    <value>Could not resolve dependency member '{0}' declared in type '{1}' specified in a 'PreserveDependency' attribute.</value>
+  </data>
+  <data name="XmlCouldNotResolveAssemblyTitle" xml:space="preserve">
+    <value>The assembly in the XML could not be resolved.</value>
+  </data>
+  <data name="XmlCouldNotResolveAssemblyMessage" xml:space="preserve">
+    <value>Could not resolve assembly '{0}'.</value>
+  </data>
+  <data name="XmlCouldNotResolveTypeTitle" xml:space="preserve">
+    <value>The type in the XML could not be resolved.</value>
+  </data>
+  <data name="XmlCouldNotResolveTypeMessage" xml:space="preserve">
+    <value>Could not resolve type '{0}'.</value>
+  </data>
+  <data name="XmlCouldNotFindMethodOnTypeTitle" xml:space="preserve">
+    <value>The XML defined a method on a type, but the method was not found.</value>
+  </data>
+  <data name="XmlCouldNotFindMethodOnTypeMessage" xml:space="preserve">
+    <value>Could not find method '{0}' on type '{1}'.</value>
+  </data>
+  <data name="XmlInvalidValueForStubTitle" xml:space="preserve">
+    <value>Invalid value for 'signature' stub in the substitution XML.</value>
+  </data>
+  <data name="XmlInvalidValueForStubMessage" xml:space="preserve">
+    <value>Invalid value for '{0}' stub.</value>
+  </data>
+  <data name="XmlUnkownBodyModificationTitle" xml:space="preserve">
+    <value>The value of the body attribute used in the substitution XML is invalid (the only supported options are remove and stub).</value>
+  </data>
+  <data name="XmlUnkownBodyModificationMessage" xml:space="preserve">
+    <value>Unknown body modification '{0}' for '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindFieldOnTypeTitle" xml:space="preserve">
+    <value>The XML defined a field on a type, but the field was not found.</value>
+  </data>
+  <data name="XmlCouldNotFindFieldOnTypeMessage" xml:space="preserve">
+    <value>Could not find field '{0}' on type '{1}'.</value>
+  </data>
+  <data name="XmlSubstitutedFieldNeedsToBeStaticTitle" xml:space="preserve">
+    <value>The substituted field 'field' was non-static or constant. Only static non-constant fields are supported.</value>
+  </data>
+  <data name="XmlSubstitutedFieldNeedsToBeStaticMessage" xml:space="preserve">
+    <value>Substituted field '{0}' needs to be static field.</value>
+  </data>
+  <data name="XmlMissingSubstitutionValueForFieldTitle" xml:space="preserve">
+    <value>A field was specified for substitution but no value to be substituted was given.</value>
+  </data>
+  <data name="XmlMissingSubstitutionValueForFieldMessage" xml:space="preserve">
+    <value>Missing 'value' attribute for field '{0}'.</value>
+  </data>
+  <data name="XmlInvalidSubstitutionValueForFieldTitle" xml:space="preserve">
+    <value>The value used in the substitution XML for field is not a built-in type, or does not match the type of the field.</value>
+  </data>
+  <data name="XmlInvalidSubstitutionValueForFieldMessage" xml:space="preserve">
+    <value>Invalid value '{0}' for '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindEventOnTypeTitle" xml:space="preserve">
+    <value>The XML defined a event on a type, but the event was not found.</value>
+  </data>
+  <data name="XmlCouldNotFindEventOnTypeMessage" xml:space="preserve">
+    <value>Could not find event '{0}' on type '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindPropertyOnTypeTitle" xml:space="preserve">
+    <value>The XML defined a property on a type, but the property was not found.</value>
+  </data>
+  <data name="XmlCouldNotFindPropertyOnTypeMessage" xml:space="preserve">
+    <value>Could not find property '{0}' on type '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindGetAccesorOfPropertyOnTypeTitle" xml:space="preserve">
+    <value>The XML defined the get accessor of property on a type, but the accessor was not found.</value>
+  </data>
+  <data name="XmlCouldNotFindGetAccesorOfPropertyOnTypeMessage" xml:space="preserve">
+    <value>Could not find the get accessor of property '{0}' on type '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindSetAccesorOfPropertyOnTypeTitle" xml:space="preserve">
+    <value>The XML defined the set accessor of property on a type, but the accessor was not found.</value>
+  </data>
+  <data name="XmlCouldNotFindSetAccesorOfPropertyOnTypeMessage" xml:space="preserve">
+    <value>Could not find the set accessor of property '{0}' in type '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindMatchingConstructorForCustomAttributeTitle" xml:space="preserve">
+    <value>The XML attribute arguments use values or types which don't match to any constructor</value>
+  </data>
+  <data name="XmlCouldNotFindMatchingConstructorForCustomAttributeMessage" xml:space="preserve">
+    <value>Could not find matching constructor for custom attribute '{0}' arguments.</value>
+  </data>
+  <data name="XmlMoreThanOneReturnElementForMethodTitle" xml:space="preserve">
+    <value>Method 'method' has more than one return element specified. There can only be one return element.</value>
+  </data>
+  <data name="XmlMoreThanOneReturnElementForMethodMessage" xml:space="preserve">
+    <value>There is more than one 'return' child element specified for method '{0}'.</value>
+  </data>
+  <data name="XmlMoreThanOneValyForParameterOfMethodTitle" xml:space="preserve">
+    <value>Method has more than one parameter for the XML element 'parameter'. There can only be one value specified for each parameter.</value>
+  </data>
+  <data name="XmlMoreThanOneValyForParameterOfMethodMessage" xml:space="preserve">
+    <value>More than one value specified for parameter '{0}' of method '{1}'.</value>
+  </data>
+  <data name="XmlDuplicatePreserveMemberTitle" xml:space="preserve">
+    <value>The XML descriptor marks for preservation the member more than once.</value>
+  </data>
+  <data name="XmlDuplicatePreserveMemberMessage" xml:space="preserve">
+    <value>Duplicate preserve of '{0}'.</value>
+  </data>
   <data name="RequiresUnreferencedCodeTitle" xml:space="preserve">
     <value>Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code</value>
   </data>
   <data name="RequiresUnreferencedCodeMessage" xml:space="preserve">
     <value>Using member '{0}' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code.{1}{2}</value>
   </data>
+  <data name="DynamicTypeInvocationTitle" xml:space="preserve">
+    <value>Using dynamic types might cause types or members to be removed by trimmer.</value>
+  </data>
+  <data name="DynamicTypeInvocationMessage" xml:space="preserve">
+    <value>Invoking members on dynamic types is not trimming-compatible. Types or members might have been removed by the trimmer.</value>
+  </data>
+  <data name="AttributeShouldOnlyBeUsedOnceOnMemberTitle" xml:space="preserve">
+    <value>The linker found multiple instances of attribute on a member. This attribute is only allowed to have one instance.</value>
+  </data>
+  <data name="AttributeShouldOnlyBeUsedOnceOnMemberMessage" xml:space="preserve">
+    <value>Attribute '{0}' should only be used once on '{1}</value>
+  </data>
+  <data name="AttributeDoesntHaveTheRequiredNumberOfParametersTitle" xml:space="preserve">
+    <value>Attribute doesn't have the required number of parameters specified.</value>
+  </data>
+  <data name="AttributeDoesntHaveTheRequiredNumberOfParametersMessage" xml:space="preserve">
+    <value>Attribute '{0}' doesn't have the required number of parameters specified.</value>
+  </data>
+  <data name="XmlElementDoesNotContainRequiredAttributeFullnameTitle" xml:space="preserve">
+    <value>'attribute' element does not contain attribute 'fullname' or it's empty.</value>
+  </data>
+  <data name="XmlElementDoesNotContainRequiredAttributeFullnameMessage" xml:space="preserve">
+    <value>'attribute' element does not contain attribute 'fullname' or it's empty.</value>
+  </data>
+  <data name="XmlCouldNotResolveAssemblyForAttributeTitle" xml:space="preserve">
+    <value>The assembly name specified for attribute could not be resolved.</value>
+  </data>
+  <data name="XmlCouldNotResolveAssemblyForAttributeMessage" xml:space="preserve">
+    <value>Could not resolve assembly '{0}' for attribute '{1}'.</value>
+  </data>
+  <data name="XmlAttributeTypeCouldNotBeFoundTitle" xml:space="preserve">
+    <value>The described attribute type could not be found in the assemblies.</value>
+  </data>
+  <data name="XmlAttributeTypeCouldNotBeFoundMessage" xml:space="preserve">
+    <value>Attribute type '{0}' could not be found.</value>
+  </data>
+  <data name="UnrecognizedParameterInMethodCreateInstanceTitle" xml:space="preserve">
+    <value>The value passed as the assembly name or type name to the CreateInstance method can't be statically analyzed.</value>
+  </data>
+  <data name="UnrecognizedParameterInMethodCreateInstanceMessage" xml:space="preserve">
+    <value>Unrecognized value passed to the parameter '{0}' of method '{1}'. It's not possible to guarantee the availability of the target type.</value>
+  </data>
+  <data name="DeprecatedPreserveDependencyAttributeTitle" xml:space="preserve">
+    <value>'PreserveDependencyAttribute' is deprecated. Use 'DynamicDependencyAttribute' instead.</value>
+  </data>
+  <data name="DeprecatedPreserveDependencyAttributeMessage" xml:space="preserve">
+    <value>'PreserveDependencyAttribute' is deprecated. Use 'DynamicDependencyAttribute' instead.</value>
+  </data>
+  <data name="DynamicDependencyAttributeCouldNotBeAnalyzedTitle" xml:space="preserve">
+    <value>The input contains an invalid use of DynamicDependencyAttribute.</value>
+  </data>
+  <data name="DynamicDependencyAttributeCouldNotBeAnalyzedMessage" xml:space="preserve">
+    <value>The 'DynamicDependencyAttribute' could not be analyzed.</value>
+  </data>
+  <data name="UnresolvedAssemblyInDynamicDependencyAttributeTitle" xml:space="preserve">
+    <value>The assembly string given in a DynamicDependencyAttribute constructor could not be resolved.</value>
+  </data>
+  <data name="UnresolvedAssemblyInDynamicDependencyAttributeMessage" xml:space="preserve">
+    <value>Unresolved assembly '{0}' in 'DynamicDependencyAttribute'.</value>
+  </data>
+  <data name="UnresolvedTypeInDynamicDependencyAttributeTitle" xml:space="preserve">
+    <value>The type in a DynamicDependencyAttribute constructor could not be resolved.</value>
+  </data>
+  <data name="UnresolvedTypeInDynamicDependencyAttributeMessage" xml:space="preserve">
+    <value>Unresolved type '{0}' in 'DynamicDependencyAttribute'.</value>
+  </data>
+  <data name="NoMembersResolvedForMemberSignatureOrTypeTitle" xml:space="preserve">
+    <value>The member signature or DynamicallyAccessedMemberTypes in a DynamicDependencyAttribute constructor did not resolve to any members on the type.</value>
+  </data>
+  <data name="NoMembersResolvedForMemberSignatureOrTypeMessage" xml:space="preserve">
+    <value>No members were resolved for '{0}'.</value>
+  </data>
+  <data name="XmlMissingNameAttributeInResourceTitle" xml:space="preserve">
+    <value>The resource element in a substitution file did not have a 'name' attribute.</value>
+  </data>
+  <data name="XmlMissingNameAttributeInResourceMessage" xml:space="preserve">
+    <value>Missing 'name' attribute for resource.</value>
+  </data>
+  <data name="XmlInvalidValueForAttributeActionForResourceTitle" xml:space="preserve">
+    <value>The resource element in a substitution file did not have a valid 'action' attribute.</value>
+  </data>
+  <data name="XmlInvalidValueForAttributeActionForResourceMessage" xml:space="preserve">
+    <value>Invalid value '{0}' for attribute 'action' for resource '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindResourceToRemoveInAssemblyTitle" xml:space="preserve">
+    <value>The resource name in a substitution file could not be found in the specified assembly.</value>
+  </data>
+  <data name="XmlCouldNotFindResourceToRemoveInAssemblyMessage" xml:space="preserve">
+    <value>Could not find embedded resource '{0}' to remove in assembly '{1}'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersIsNotAllowedOnMethodsTitle" xml:space="preserve">
+    <value>The 'DynamicallyAccessedMembersAttribute' is not allowed on methods. It is allowed on method return value or method parameters.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersIsNotAllowedOnMethodsMessage" xml:space="preserve">
+    <value>The 'DynamicallyAccessedMembersAttribute' is not allowed on methods. It is allowed on method return value or method parameters though.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersCouldNotFindBackingFieldTitle" xml:space="preserve">
+    <value>Could not find a unique backing field for property to propagate 'DynamicallyAccessedMembersAttribute'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersCouldNotFindBackingFieldMessage" xml:space="preserve">
+    <value>Could not find a unique backing field for property '{0}' to propagate 'DynamicallyAccessedMembersAttribute'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersConflictsBetweenPropertyAndAccessorTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on property conflicts with the same attribute on its accessor.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersConflictsBetweenPropertyAndAccessorMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on property '{0}' conflicts with the same attribute on its accessor '{1}'.</value>
+  </data>
+  <data name="XmlCouldNotFindAnyTypeInNamespaceTitle" xml:space="preserve">
+    <value>The XML descriptor specifies a namespace but there are no types found in such namespace.</value>
+  </data>
+  <data name="XmlCouldNotFindAnyTypeInNamespaceMessage" xml:space="preserve">
+    <value>Could not find any type in namespace '{0}'.</value>
+  </data>
+  <data name="AttributeIsReferencedButTrimmerRemoveAllInstancesTitle" xml:space="preserve">
+    <value>An attribute is being referenced in the code but the attribute instances have been removed using the 'RemoveAttributeInstances' internal attribute.</value>
+  </data>
+  <data name="AttributeIsReferencedButTrimmerRemoveAllInstancesMessage" xml:space="preserve">
+    <value>Attribute '{0}' is being referenced in code but the trimmer was instructed to remove all instances of this attribute. If the attribute instances are necessary make sure to either remove the trimmer attribute XML portion which removes the attribute instances, or override the removal by using the trimmer XML descriptor to keep the attribute type (which in turn keeps all of its instances).</value>
+  </data>
+  <data name="RequiresUnreferencedCodeAttributeMismatchTitle" xml:space="preserve">
+    <value>'RequiresUnreferencedCodeAttribute' annotations must match across all interface implementations or overrides.</value>
+  </data>
+  <data name="RequiresUnreferencedCodeAttributeMismatchMessage" xml:space="preserve">
+    <value>{0}. 'RequiresUnreferencedCodeAttribute' annotations must match across all interface implementations or overrides.</value>
+  </data>
+  <data name="XmlRemoveAttributeInstancesCanOnlyBeUsedOnTypeTitle" xml:space="preserve">
+    <value>Internal attribute 'RemoveAttributeInstances' can only be used on attribute types.</value>
+  </data>
+  <data name="XmlRemoveAttributeInstancesCanOnlyBeUsedOnTypeMessage" xml:space="preserve">
+    <value>Internal attribute '{0}' can only be used on attribute types.</value>
+  </data>
+  <data name="CorrectnessOfCOMCannotBeGuaranteedTitle" xml:space="preserve">
+    <value>Correctness of COM interop cannot be guaranteed after trimming. Interfaces and interface members might be removed.</value>
+  </data>
+  <data name="CorrectnessOfCOMCannotBeGuaranteedMessage" xml:space="preserve">
+    <value>P/invoke method '{0}' declares a parameter with COM marshalling. Correctness of COM interop cannot be guaranteed after trimming. Interfaces and interface members might be removed.</value>
+  </data>
+  <data name="XmlPropertyDoesNotContainAttributeNameTitle" xml:space="preserve">
+    <value>An attribute element has property but this could not be found.</value>
+  </data>
+  <data name="XmlPropertyDoesNotContainAttributeNameMessage" xml:space="preserve">
+    <value>Property element does not contain attribute 'name'.</value>
+  </data>
+  <data name="XmlCouldNotFindPropertyTitle" xml:space="preserve">
+    <value>An attribute element has property but this could not be found.</value>
+  </data>
+  <data name="XmlCouldNotFindPropertyMessage" xml:space="preserve">
+    <value>Property '{0}' could not be found.</value>
+  </data>
+  <data name="MakeGenericTypeTitle" xml:space="preserve">
+    <value>Either the type on which the MakeGenericType is called can't be statically determined, or the type parameters to be used for generic arguments can't be statically determined.</value>
+  </data>
+  <data name="MakeGenericTypeMessage" xml:space="preserve">
+    <value>Call to '{0}' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic type.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnPropertyConflictsWithBackingFieldTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberAttribute' on property conflicts with the same attribute on its backing field.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnPropertyConflictsWithBackingFieldMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberAttribute' on property '{0}' conflicts with the same attribute on its backing field '{1}'.</value>
+  </data>
+  <data name="UnrecognizedTypeNameInTypeGetTypeTitle" xml:space="preserve">
+    <value>Unrecognized value passed to the parameter of method. It's not possible to guarantee the availability of the target type.</value>
+  </data>
+  <data name="UnrecognizedTypeNameInTypeGetTypeMessage" xml:space="preserve">
+    <value>Unrecognized value passed to the parameter 'typeName' of method '{0}'. It's not possible to guarantee the availability of the target type.</value>
+  </data>
+  <data name="ParametersOfAssemblyCreateInstanceCannotBeAnalyzedTitle" xml:space="preserve">
+    <value>Parameters passed to method cannot be analyzed. Consider using methods 'System.Type.GetType' and `System.Activator.CreateInstance` instead.</value>
+  </data>
+  <data name="ParametersOfAssemblyCreateInstanceCannotBeAnalyzedMessage" xml:space="preserve">
+    <value>Parameters passed to method '{0}' cannot be analyzed. Consider using methods 'System.Type.GetType' and `System.Activator.CreateInstance` instead.</value>
+  </data>
+  <data name="UnrecognizedTypeInRuntimeHelpersRunClassConstructorTitle" xml:space="preserve">
+    <value>The type passed to the RunClassConstructor is not statically known, Trimmer can't make sure that its static constructor is available.</value>
+  </data>
+  <data name="UnrecognizedTypeInRuntimeHelpersRunClassConstructorMessage" xml:space="preserve">
+    <value>Unrecognized value passed to the parameter 'type' of method '{0}'. It's not possible to guarantee the availability of the target static constructor.</value>
+  </data>
+  <data name="MakeGenericMethodTitle" xml:space="preserve">
+    <value>Call to 'System.Reflection.MethodInfo.MakeGenericMethod' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method.</value>
+  </data>
+  <data name="MakeGenericMethodMessage" xml:space="preserve">
+    <value>Call to '{0}' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method.</value>
+  </data>
+  <data name="UnresolvedAssemblyInCreateInstanceTitle" xml:space="preserve">
+    <value>Calling CreateInstance with assembly name which can't be resolved.</value>
+  </data>
+  <data name="UnresolvedAssemblyInCreateInstanceMessage" xml:space="preserve">
+    <value>The assembly name '{0}' passed to method '{1}' references assembly which is not available.</value>
+  </data>
+  <data name="MethodParameterCannotBeStaticallyDeterminedTitle" xml:space="preserve">
+    <value>The parameter of method has a DynamicallyAccessedMembersAttribute, but the value passed to it can not be statically analyzed.</value>
+  </data>
+  <data name="MethodParameterCannotBeStaticallyDeterminedMessage" xml:space="preserve">
+    <value>Value passed to parameter '{0}' of method '{1}' can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="MethodReturnValueCannotBeStaticallyDeterminedTitle" xml:space="preserve">
+    <value>The return value of method has a DynamicallyAccessedMembersAttribute, but the value returned from the method can not be statically analyzed.</value>
+  </data>
+  <data name="MethodReturnValueCannotBeStaticallyDeterminedMessage" xml:space="preserve">
+    <value>Value returned from method '{0}' can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="FieldValueCannotBeStaticallyDeterminedTitle" xml:space="preserve">
+    <value>The field has a DynamicallyAccessedMembersAttribute, but the value assigned to it can not be statically analyzed.</value>
+  </data>
+  <data name="FieldValueCannotBeStaticallyDeterminedMessage" xml:space="preserve">
+    <value>Value assigned to {0} can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="ImplicitThisCannotBeStaticallyDeterminedTitle" xml:space="preserve">
+    <value>The method has a DynamicallyAccessedMembersAttribute (which applies to the implicit 'this' parameter), but the value used for the 'this' parameter can not be statically analyzed.</value>
+  </data>
+  <data name="ImplicitThisCannotBeStaticallyDeterminedMessage" xml:space="preserve">
+    <value>Value passed to implicit 'this' parameter of method '{0}' can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="TypePassedToGenericParameterCannotBeStaticallyDeterminedTitle" xml:space="preserve">
+    <value>The generic parameter of type or method has a DynamicallyAccessedMembersAttribute, but the value used for it can not be statically analyzed.</value>
+  </data>
+  <data name="TypePassedToGenericParameterCannotBeStaticallyDeterminedMessage" xml:space="preserve">
+    <value>Type passed to generic parameter '{0}' of '{1}' can not be statically determined and may not meet 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsParameterTitle" xml:space="preserve">
+    <value>Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The parameter of method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsParameterMessage" xml:space="preserve">
+    <value>'{0}' argument does not satisfy {4} in call to '{1}'. The parameter '{2}' of method '{3}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsMethodReturnTypeTitle" xml:space="preserve">
+    <value>Target method return value does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The parameter of method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsMethodReturnTypeMessage" xml:space="preserve">
+    <value>'{0}' method return value does not satisfy {3} requirements. The parameter '{1}' of method '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsFieldTitle" xml:space="preserve">
+    <value>Value stored in field does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The parameter of method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsFieldMessage" xml:space="preserve">
+    <value>value stored in field '{0}' does not satisfy {3} requirements. The parameter '{1}' of method '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsThisParameterTitle" xml:space="preserve">
+    <value>'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The parameter of method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsThisParameterMessage" xml:space="preserve">
+    <value>'this' argument does not satisfy {3} in call to '{0}'. The parameter '{1}' of method '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsGenericParameterTitle" xml:space="preserve">
+    <value>Generic argument does not satisfy 'DynamicallyAccessedMembersAttribute' in target method or type. The parameter of method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchParameterTargetsGenericParameterMessage" xml:space="preserve">
+    <value>'{0}' generic argument does not satisfy {4} in '{1}'. The parameter '{2}' of method '{3}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsParameterTitle" xml:space="preserve">
+    <value>Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsParameterMessage" xml:space="preserve">
+    <value>'{0}' argument does not satisfy {3} in call to '{1}'. The return value of method '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsMethodReturnTypeTitle" xml:space="preserve">
+    <value>Target method return value does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The return value of the source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsMethodReturnTypeMessage" xml:space="preserve">
+    <value>'{0}' method return value does not satisfy {2} requirements. The return value of method '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsFieldTitle" xml:space="preserve">
+    <value>Value stored in field does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The return value of the source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsFieldMessage" xml:space="preserve">
+    <value>value stored in field '{0}' does not satisfy {2} requirements. The return value of method '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsThisParameterTitle" xml:space="preserve">
+    <value>'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsThisParameterMessage" xml:space="preserve">
+    <value>'this' argument does not satisfy {2} in call to '{0}'. The return value of method '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsGenericParameterTitle" xml:space="preserve">
+    <value>Target generic argument does not satisfy 'DynamicallyAccessedMembersAttribute' in target method or type. The return value of the source method does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchMethodReturnTypeTargetsGenericParameterMessage" xml:space="preserve">
+    <value>'{0}' generic argument does not satisfy {3} in '{1}'. The return value of method '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsParameterTitle" xml:space="preserve">
+    <value>Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The source field does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsParameterMessage" xml:space="preserve">
+    <value>'{0}' argument does not satisfy {3} in call to '{1}'. The field '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsMethodReturnTypeTitle" xml:space="preserve">
+    <value>Target method return value does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The source field does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsMethodReturnTypeMessage" xml:space="preserve">
+    <value>'{0}' method return value does not satisfy {2} requirements. The field '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsFieldTitle" xml:space="preserve">
+    <value>Value stored in target field does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The source field does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsFieldMessage" xml:space="preserve">
+    <value>value stored in field '{0}' does not satisfy {2} requirements. The field '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsThisParameterTitle" xml:space="preserve">
+    <value>'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The source field does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsThisParameterMessage" xml:space="preserve">
+    <value>'this' argument does not satisfy {2} in call to '{0}'. The field '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsGenericParameterTitle" xml:space="preserve">
+    <value>Target generic argument does not satisfy 'DynamicallyAccessedMembersAttribute' in target method or type. The source field does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchFieldTargetsGenericParameterMessage" xml:space="preserve">
+    <value>'{0}' generic argument does not satisfy {3} in '{1}'. The field '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsParameterTitle" xml:space="preserve">
+    <value>Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The implicit 'this' argument of source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsParameterMessage" xml:space="preserve">
+    <value>'{0}' argument does not satisfy {3} in call to '{1}'. The implicit 'this' argument of method '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsMethodReturnTypeTitle" xml:space="preserve">
+    <value>Target method return value does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The implicit 'this' argument of source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsMethodReturnTypeMessage" xml:space="preserve">
+    <value>'{0}' method return value does not satisfy {2} requirements. The implicit 'this' argument of method '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsFieldTitle" xml:space="preserve">
+    <value>Value stored in target field does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The implicit 'this' argument of source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsFieldMessage" xml:space="preserve">
+    <value>value stored in field '{0}' does not satisfy {2} requirements. The implicit 'this' argument of method '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsThisParameterTitle" xml:space="preserve">
+    <value>'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The implicit 'this' argument of source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsThisParameterMessage" xml:space="preserve">
+    <value>'this' argument does not satisfy {2} in call to '{0}'. The implicit 'this' argument of method '{1}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsGenericParameterTitle" xml:space="preserve">
+    <value>Target generic argument does not satisfy 'DynamicallyAccessedMembersAttribute' in target method or type. The implicit 'this' argument of source method does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchThisParameterTargetsGenericParameterMessage" xml:space="preserve">
+    <value>'{0}' generic argument does not satisfy {3} in '{1}'. The implicit 'this' argument of method '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsParameterTitle" xml:space="preserve">
+    <value>Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The generic parameter of the source method or type does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsParameterMessage" xml:space="preserve">
+    <value>'{0}' argument does not satisfy {4} in call to '{1}'. The generic parameter '{2}' of '{3}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsMethodReturnTypeTitle" xml:space="preserve">
+    <value>Target method return value does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The generic parameter of the source method or type does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsMethodReturnTypeMessage" xml:space="preserve">
+    <value>'{0}' method return value does not satisfy {3} requirements. The generic parameter '{1}' of '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsFieldTitle" xml:space="preserve">
+    <value>Value stored in target field does not satisfy 'DynamicallyAccessedMembersAttribute' requirements. The generic parameter of the source method or type does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsFieldMessage" xml:space="preserve">
+    <value>value stored in field '{0}' does not satisfy {3} requirements. The generic parameter '{1}' of '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsThisParameterTitle" xml:space="preserve">
+    <value>'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The generic parameter of the source method or type does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsThisParameterMessage" xml:space="preserve">
+    <value>'this' argument does not satisfy {3} in call to '{0}'. The generic parameter '{1}' of '{2}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsGenericParameterTitle" xml:space="preserve">
+    <value>Target generic argument does not satisfy 'DynamicallyAccessedMembersAttribute' in target method or type. The generic parameter of the source method or type does not have matching annotations.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchTypeArgumentTargetsGenericParameterMessage" xml:space="preserve">
+    <value>'{0}' generic argument does not satisfy {4} in '{1}'. The generic parameter '{2}' of '{3}' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnMethodParameterBetweenOverridesTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' on the parameter of method don't match overridden parameter of method. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnMethodParameterBetweenOverridesMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the parameter '{0}' of method '{1}' don't match overridden parameter '{2}' of method '{3}'. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnMethodReturnValueBetweenOverridesTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' on the return value of method don't match overridden return value of method. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnMethodReturnValueBetweenOverridesMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the return value of method '{0}' don't match overridden return value of method '{1}'. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnImplicitThisBetweenOverridesTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' on the implicit 'this' parameter of method don't match overridden implicit 'this' parameter of method. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnImplicitThisBetweenOverridesMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the implicit 'this' parameter of method '{0}' don't match overridden implicit 'this' parameter of method '{1}'. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnGenericParameterBetweenOverridesTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' on the generic parameter of method or type don't match overridden generic parameter method or type. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMismatchOnGenericParameterBetweenOverridesMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the generic parameter '{0}' of '{1}' don't match overridden generic parameter '{2}' of '{3}'. All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.</value>
+  </data>
+  <data name="CaseInsensitiveTypeGetTypeCallIsNotSupportedTitle" xml:space="preserve">
+    <value>Call to 'Type.GetType' method can perform case insensitive lookup of the type, currently ILLink can not guarantee presence of all the matching types.</value>
+  </data>
+  <data name="CaseInsensitiveTypeGetTypeCallIsNotSupportedMessage" xml:space="preserve">
+    <value>Call to '{0}' can perform case insensitive lookup of the type, currently ILLink can not guarantee presence of all the matching types.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnFieldCanOnlyApplyToTypesOrStringsTitle" xml:space="preserve">
+    <value>Field has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to fields of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnFieldCanOnlyApplyToTypesOrStringsMessage" xml:space="preserve">
+    <value>Field '{0}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to fields of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnMethodParameterCanOnlyApplyToTypesOrStringsTitle" xml:space="preserve">
+    <value>Parameter of method has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to parameters of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnMethodParameterCanOnlyApplyToTypesOrStringsMessage" xml:space="preserve">
+    <value>Parameter '{0}' of method '{1}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to parameters of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnPropertyCanOnlyApplyToTypesOrStringsTitle" xml:space="preserve">
+    <value>Property has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to properties of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnPropertyCanOnlyApplyToTypesOrStringsMessage" xml:space="preserve">
+    <value>Property '{0}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to properties of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="XmlUnsuportedWildcardTitle" xml:space="preserve">
+    <value>XML contains unsupported wildcard for assembly 'fullname' attribute.</value>
+  </data>
+  <data name="XmlUnsuportedWildcardMessage" xml:space="preserve">
+    <value>XML contains unsupported wildcard for assembly 'fullname' attribute.</value>
+  </data>
+  <data name="AssemblyWithEmbeddedXmlApplyToAnotherAssemblyTitle" xml:space="preserve">
+    <value>Embedded XML in assembly contains assembly "fullname" attribute for another assembly</value>
+  </data>
+  <data name="AssemblyWithEmbeddedXmlApplyToAnotherAssemblyMessage" xml:space="preserve">
+    <value>Embedded XML in assembly '{0}' contains assembly "fullname" attribute for another assembly '{1}'</value>
+  </data>
+  <data name="InvalidIsTrimmableValueTitle" xml:space="preserve">
+    <value>Invalid AssemblyMetadata 'IsTrimmable' attribute in assembly. Value must be "True".</value>
+  </data>
+  <data name="InvalidIsTrimmableValueMessage" xml:space="preserve">
+    <value>Invalid AssemblyMetadata("IsTrimmable", "{0}") attribute in assembly '{1}'. Value must be "True".</value>
+  </data>
+  <data name="PropertyAccessorParameterInLinqExpressionsCannotBeStaticallyDeterminedTitle" xml:space="preserve">
+    <value>Value passed to the parameter of method cannot be statically determined as a property accessor.</value>
+  </data>
+  <data name="PropertyAccessorParameterInLinqExpressionsCannotBeStaticallyDeterminedMessage" xml:space="preserve">
+    <value>Value passed to the '{0}' parameter of method '{1}' cannot be statically determined as a property accessor.</value>
+  </data>
+  <data name="AssemblyProducedTrimWarningsTitle" xml:space="preserve">
+    <value>Assembly produced trim warnings.</value>
+  </data>
+  <data name="AssemblyProducedTrimWarningsMessage" xml:space="preserve">
+    <value>Assembly '{0}' produced trim warnings. For more information see https://aka.ms/dotnet-illink/libraries</value>
+  </data>
+  <data name="TypeWasNotFoundInAssemblyNorBaseLibraryTitle" xml:space="preserve">
+    <value>Type was not found in the caller assembly nor in the base library. Type name strings used for dynamically accessing a type should be assembly qualified.</value>
+  </data>
+  <data name="TypeWasNotFoundInAssemblyNorBaseLibraryMessage" xml:space="preserve">
+    <value>Type '{0}' was not found in the caller assembly nor in the base library. Type name strings used for dynamically accessing a type should be assembly qualified.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnMethodReturnValueCanOnlyApplyToTypesOrStringsTitle" xml:space="preserve">
+    <value>Return type of method has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to properties of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnMethodReturnValueCanOnlyApplyToTypesOrStringsMessage" xml:space="preserve">
+    <value>Return type of method '{0}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to properties of type 'System.Type' or 'System.String'.</value>
+  </data>
+  <data name="MethodsAreAssociatedWithStateMachineTitle" xml:space="preserve">
+    <value>Trimmer currently can't correctly handle if the same compiler generated state machine type is associated (via the state machine attributes) with two different methods.</value>
+  </data>
+  <data name="MethodsAreAssociatedWithStateMachineMessage" xml:space="preserve">
+    <value>Methods '{0}' and '{1}' are both associated with state machine type '{2}'. This is currently unsupported and may lead to incorrectly reported warnings.</value>
+  </data>
+  <data name="InvalidScopeInUnconditionalSuppressMessageTitle" xml:space="preserve">
+    <value>Invalid scope used in 'UnconditionalSuppressMessageAttribute'. The only scopes supported on global unconditional suppressions are 'module', 'type' and 'member'.</value>
+  </data>
+  <data name="InvalidScopeInUnconditionalSuppressMessageMessage" xml:space="preserve">
+    <value>Invalid scope '{0}' used in 'UnconditionalSuppressMessageAttribute' on module '{1}' with target '{2}'.</value>
+  </data>
+  <data name="RequiresUnreferencedCodeOnBaseClassTitle" xml:space="preserve">
+    <value>Types that derive from a base class with 'RequiresUnreferencedCodeAttribute' need to explicitly use the 'RequiresUnreferencedCodeAttribute' or suppress this warning</value>
+  </data>
+  <data name="RequiresUnreferencedCodeOnBaseClassMessage" xml:space="preserve">
+    <value>Type '{0}' derives from '{1}' which has 'RequiresUnreferencedCodeAttribute'. {2}{3}</value>
+  </data>
+  <data name="DynamicallyAccessedMembersFieldAccessedViaReflectionTitle" xml:space="preserve">
+    <value>Field with 'DynamicallyAccessedMembersAttribute' is accessed via reflection. Trimmer can't guarantee availability of the requirements of the field.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersFieldAccessedViaReflectionMessage" xml:space="preserve">
+    <value>Field '{0}' with 'DynamicallyAccessedMembersAttribute' is accessed via reflection. Trimmer can't guarantee availability of the requirements of the field.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMethodAccessedViaReflectionTitle" xml:space="preserve">
+    <value>Method with parameters or return value with `DynamicallyAccessedMembersAttribute` is accessed via reflection. Trimmer can't guarantee availability of the requirements of the method.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersMethodAccessedViaReflectionMessage" xml:space="preserve">
+    <value>Method '{0}' with parameters or return value with `DynamicallyAccessedMembersAttribute` is accessed via reflection. Trimmer can't guarantee availability of the requirements of the method.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberWithRequiresUnreferencedCodeTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on a type or one of its base types references a member which requires unreferenced code.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberWithRequiresUnreferencedCodeMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on '{0}' or one of its base types references '{1}' which requires unreferenced code.{2}{3}</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithRequiresUnreferencedCodeTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on a type or one of its base types references a member which requires unreferenced code.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithRequiresUnreferencedCodeMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on '{0}' or one of its base types references '{1}' which requires unreferenced code.{2}{3}</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberWithDynamicallyAccessedMembersTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on a type or one of its base types references a member which has 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberWithDynamicallyAccessedMembersMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on '{0}' or one of its base types references '{1}' which has 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithDynamicallyAccessedMembersTitle" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on a type or one of its base types references a member which has 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithDynamicallyAccessedMembersMessage" xml:space="preserve">
+    <value>'DynamicallyAccessedMembersAttribute' on '{0}' or one of its base types references '{1}' which has 'DynamicallyAccessedMembersAttribute' requirements.</value>
+  </data>
+  <data name="RequiresUnreferencedCodeOnStaticConstructorTitle" xml:space="preserve">
+    <value>The use of 'RequiresUnreferencedCodeAttribute' on static constructors is disallowed since is a method not callable by the user, is only called by the runtime. Placing the attribute directly on the static constructor will have no effect, instead use 'RequiresUnreferencedCodeAttribute' on the type which will handle warning and silencing from the static constructor.</value>
+  </data>
+  <data name="RequiresUnreferencedCodeOnStaticConstructorMessage" xml:space="preserve">
+    <value>'RequiresUnreferencedCodeAttribute' cannot be placed directly on static constructor '{0}', consider placing 'RequiresUnreferencedCodeAttribute' on the type declaration instead.</value>
+  </data>
   <data name="AvoidAssemblyLocationInSingleFileTitle" xml:space="preserve">
     <value>Avoid accessing Assembly file path when publishing as a single file</value>
   </data>
@@ -141,29 +1082,23 @@
   <data name="RequiresAssemblyFilesMessage" xml:space="preserve">
     <value>Using member '{0}' which has 'RequiresAssemblyFilesAttribute' can break functionality when embedded in a single-file app.{1}{2}</value>
   </data>
+  <data name="RequiresAssemblyFilesAttributeMismatchTitle" xml:space="preserve">
+    <value>'RequiresAssemblyFilesAttribute' annotations must match across all interface implementations or overrides.</value>
+  </data>
+  <data name="RequiresAssemblyFilesAttributeMismatchMessage" xml:space="preserve">
+    <value>{0}. 'RequiresAssemblyFilesAttribute' annotations must match across all interface implementations or overrides.</value>
+  </data>
   <data name="RequiresDynamicCodeTitle" xml:space="preserve">
     <value>Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.</value>
   </data>
   <data name="RequiresDynamicCodeMessage" xml:space="preserve">
     <value>Using member '{0}' which has 'RequiresDynamicCodeAttribute' can break functionality when AOT compiling.{1}{2}</value>
   </data>
-  <data name="RequiresUnreferencedCodeAttributeMismatchMessage" xml:space="preserve">
-    <value>{0}. 'RequiresUnreferencedCodeAttribute' annotations must match across all interface implementations or overrides.</value>
-  </data>
-  <data name="RequiresUnreferencedCodeAttributeMismatchTitle" xml:space="preserve">
-    <value>'RequiresUnreferencedCodeAttribute' annotations must match across all interface implementations or overrides.</value>
-  </data>
-  <data name="RequiresDynamicCodeAttributeMismatchMessage" xml:space="preserve">
-    <value>{0}. 'RequiresDynamicCodeAttribute' annotations must match across all interface implementations or overrides.</value>
-  </data>
   <data name="RequiresDynamicCodeAttributeMismatchTitle" xml:space="preserve">
     <value>'RequiresDynamicCodeAttribute' annotations must match across all interface implementations or overrides.</value>
   </data>
-  <data name="RequiresAssemblyFilesAttributeMismatchMessage" xml:space="preserve">
-    <value>{0}. 'RequiresAssemblyFilesAttribute' annotations must match across all interface implementations or overrides.</value>
-  </data>
-  <data name="RequiresAssemblyFilesAttributeMismatchTitle" xml:space="preserve">
-    <value>'RequiresAssemblyFilesAttribute' annotations must match across all interface implementations or overrides.</value>
+  <data name="RequiresDynamicCodeAttributeMismatchMessage" xml:space="preserve">
+    <value>{0}. 'RequiresDynamicCodeAttribute' annotations must match across all interface implementations or overrides.</value>
   </data>
   <data name="BaseRequiresMismatchMessage" xml:space="preserve">
     <value>Base member '{2}' with '{0}' has a derived member '{1}' without '{0}'</value>
@@ -177,38 +1112,8 @@
   <data name="InterfaceRequiresMismatchMessage" xml:space="preserve">
     <value>Interface member '{2}' with '{0}' has an implementation member '{1}' without '{0}'</value>
   </data>
-  <data name="RequiresOnBaseClassMessage" xml:space="preserve">
-    <value>Type '{0}' derives from '{1}' which has 'RequiresUnreferencedCodeAttribute'. {2}{3}</value>
-  </data>
-  <data name="RequiresOnBaseClassTitle" xml:space="preserve">
-    <value>Types that derive from a base class with 'RequiresUnreferencedCodeAttribute' need to explicitly use the 'RequiresUnreferencedCodeAttribute' or suppress this warning</value>
-  </data>
-  <data name="DynamicTypeInvocationMessage" xml:space="preserve">
-    <value>Invoking members on dynamic types is not trimming-compatible. Types or members might have been removed by the trimmer.</value>
-  </data>
-  <data name="DynamicTypeInvocationTitle" xml:space="preserve">
-    <value>Using dynamic types might cause types or members to be removed by trimmer.</value>
-  </data>
-  <data name="MakeGenericMethodMessage" xml:space="preserve">
-    <value>Call to '{0}' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method.</value>
-  </data>
-  <data name="MakeGenericTypeMessage" xml:space="preserve">
-    <value>Call to '{0}' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic type.</value>
-  </data>
-  <data name="RequiresUnreferencedCodeOnStaticConstructorMessage" xml:space="preserve">
-    <value>'RequiresUnreferencedCodeAttribute' cannot be placed directly on static constructor '{0}', consider placing 'RequiresUnreferencedCodeAttribute' on the type declaration instead.</value>
-  </data>
-  <data name="RequiresUnreferencedCodeOnStaticConstructorTitle" xml:space="preserve">
-    <value>The use of 'RequiresUnreferencedCodeAttribute' on static constructors is disallowed since is a method not callable by the user, is only called by the runtime. Placing the attribute directly on the static constructor will have no effect, instead use 'RequiresUnreferencedCodeAttribute' on the type which will handle warning and silencing from the static constructor.</value>
-  </data>
-  <data name="MakeGenericMethodCannotBeStaticallyAnalyzedMessage" xml:space="preserve">
-    <value>Call to '{0}' can not be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method.</value>
-  </data>
-  <data name="PropertyAccessorParameterInLinqExpressionsCannotBeStaticallyDeterminedMessage" xml:space="preserve">
-    <value>Value passed to the '{0}' parameter of method '{1}' cannot be statically determined as a property accessor.</value>
-  </data>
-  <data name="CorrectnessOfCOMCannotBeGuaranteedMessage" xml:space="preserve">
-    <value>P/invoke method '{0}' declares a parameter with COM marshalling. Correctness of COM interop cannot be guaranteed after trimming. Interfaces and interface members might be removed.</value>
+  <data name="CorrectnessOfAbstractDelegatesCannotBeGuaranteedTitle" xml:space="preserve">
+    <value>P/invoke method declares a parameter with an abstract delegate. Correctness of interop for abstract delegates cannot be guaranteed after native compilation.</value>
   </data>
   <data name="CorrectnessOfAbstractDelegatesCannotBeGuaranteedMessage" xml:space="preserve">
     <value>P/invoke method '{0}' declares a parameter with an abstract delegate. Correctness of interop for abstract delegates cannot be guaranteed after native compilation: the marshalling code for the delegate might not be available. Use a non-abstract delegate type or ensure any delegate instance passed as parameter is marked with `UnmanagedFunctionPointerAttribute`.</value>

From 09ff1acdad2e7789908b5db9bb89896144c13042 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Mon, 24 Jan 2022 14:39:27 +0900
Subject: [PATCH 016/161] Allow generating Dwarf version 5 (#63988)

Contributes to https://github.com/dotnet/runtimelab/issues/1738.
---
 .../BuildIntegration/Microsoft.NETCore.Native.targets    | 1 +
 .../Compiler/CompilationBuilder.Aot.cs                   | 7 +++++++
 .../Compiler/DependencyAnalysis/ObjectWriter.cs          | 9 +++++++++
 .../aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs  | 4 ++++
 .../Compiler/RyuJitCompilationBuilder.cs                 | 3 +++
 src/coreclr/tools/aot/ILCompiler/Program.cs              | 5 ++++-
 6 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
index 1a3b4a2f740b41..365afaa6ce4687 100644
--- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
+++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
@@ -247,6 +247,7 @@ The .NET Foundation licenses this file to you under the MIT license.
       <IlcArg Condition="$(IlcMultiModule) == 'true'" Include="--multifile" />
       <IlcArg Condition="$(Optimize) == 'true'" Include="-O" />
       <IlcArg Condition="$(NativeDebugSymbols) == 'true'" Include="-g" />
+      <IlcArg Condition="$(IlcDwarfVersion) == '5'" Include="--gdwarf-5" />
       <IlcArg Condition="$(IlcGenerateMapFile) == 'true'" Include="--map:$(NativeIntermediateOutputPath)%(ManagedBinary.Filename).map.xml" />
       <IlcArg Condition="$(IlcGenerateDgmlFile) == 'true'" Include="--dgmllog:$(NativeIntermediateOutputPath)%(ManagedBinary.Filename).codegen.dgml.xml" />
       <IlcArg Condition="$(IlcGenerateDgmlFile) == 'true'" Include="--scandgmllog:$(NativeIntermediateOutputPath)%(ManagedBinary.Filename).scan.dgml.xml" />
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilationBuilder.Aot.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilationBuilder.Aot.cs
index fb4ad5ce51b7f6..232df5cd22d4e2 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilationBuilder.Aot.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilationBuilder.Aot.cs
@@ -24,6 +24,7 @@ partial class CompilationBuilder
         protected bool _methodBodyFolding;
         protected InstructionSetSupport _instructionSetSupport;
         protected SecurityMitigationOptions _mitigationOptions;
+        protected bool _useDwarf5;
 
         partial void InitializePartial()
         {
@@ -103,6 +104,12 @@ public CompilationBuilder UseMethodImportationErrorProvider(MethodImportationErr
             return this;
         }
 
+        public CompilationBuilder UseDwarf5(bool value)
+        {
+            _useDwarf5 = value;
+            return this;
+        }
+
         protected PreinitializationManager GetPreinitializationManager()
         {
             if (_preinitializationManager == null)
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ObjectWriter.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ObjectWriter.cs
index e690b5d420078e..5462b8fedc11ba 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ObjectWriter.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ObjectWriter.cs
@@ -85,6 +85,9 @@ public class ObjectWriter : IDisposable, ITypesDebugInfoWriter
         [DllImport(NativeObjectWriterFileName)]
         private static extern void FinishObjWriter(IntPtr objWriter);
 
+        [DllImport(NativeObjectWriterFileName)]
+        private static extern void SetDwarfVersion(IntPtr objWriter, ushort v);
+
         [DllImport(NativeObjectWriterFileName)]
         private static extern void SwitchSection(IntPtr objWriter, string sectionName, CustomSectionAttributes attributes = 0, string comdatName = null);
 
@@ -884,6 +887,11 @@ public ObjectWriter(string objectFilePath, NodeFactory factory, ObjectWritingOpt
             _isSingleFileCompilation = _nodeFactory.CompilationModuleGroup.IsSingleFileCompilation;
             _userDefinedTypeDescriptor = new UserDefinedTypeDescriptor(this, factory);
             _options = options;
+
+            if ((_options & ObjectWritingOptions.UseDwarf5) != 0)
+            {
+                SetDwarfVersion(_nativeObjectWriter, 5);
+            }
         }
 
         public void Dispose()
@@ -1319,5 +1327,6 @@ public enum ObjectWritingOptions
     {
         GenerateDebugInfo = 0x01,
         ControlFlowGuard = 0x02,
+        UseDwarf5 = 0x4,
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
index b27f7db8ec7d8e..f05301ce6367e7 100644
--- a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
+++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
@@ -93,6 +93,9 @@ protected override void CompileInternal(string outputFile, ObjectDumper dumper)
             NodeFactory.SetMarkingComplete();
 
             ObjectWritingOptions options = default;
+            if ((_compilationOptions & RyuJitCompilationOptions.UseDwarf5) != 0)
+                options |= ObjectWritingOptions.UseDwarf5;
+            
             if (_debugInformationProvider is not NullDebugInformationProvider)
                 options |= ObjectWritingOptions.GenerateDebugInfo;
 
@@ -243,5 +246,6 @@ public enum RyuJitCompilationOptions
     {
         MethodBodyFolding = 0x1,
         ControlFlowGuardAnnotations = 0x2,
+        UseDwarf5 = 0x4,
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs
index 8b753c71039942..628277d75e6f5c 100644
--- a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs
+++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs
@@ -110,6 +110,9 @@ public override ICompilation ToCompilation()
             if ((_mitigationOptions & SecurityMitigationOptions.ControlFlowGuardAnnotations) != 0)
                 options |= RyuJitCompilationOptions.ControlFlowGuardAnnotations;
 
+            if (_useDwarf5)
+                options |= RyuJitCompilationOptions.UseDwarf5;
+
             var factory = new RyuJitNodeFactory(_context, _compilationGroup, _metadataManager, _interopStubManager, _nameMangler, _vtableSliceProvider, _dictionaryLayoutProvider, GetPreinitializationManager());
 
             JitConfigProvider.Initialize(_context.Target, jitFlagBuilder.ToArray(), _ryujitOptions);
diff --git a/src/coreclr/tools/aot/ILCompiler/Program.cs b/src/coreclr/tools/aot/ILCompiler/Program.cs
index e973c05b08c2c6..6cfa82c81b2b0b 100644
--- a/src/coreclr/tools/aot/ILCompiler/Program.cs
+++ b/src/coreclr/tools/aot/ILCompiler/Program.cs
@@ -61,6 +61,7 @@ internal class Program
         private string _instructionSet;
         private string _guard;
         private int _maxGenericCycle = CompilerTypeSystemContext.DefaultGenericCycleCutoffPoint;
+        private bool _useDwarf5;
 
         private string _singleMethodTypeName;
         private string _singleMethodName;
@@ -178,6 +179,7 @@ private ArgumentSyntax ParseCommandLine(string[] args)
                 syntax.DefineOption("Ot", ref optimizeTime, "Enable optimizations, favor code speed");
                 syntax.DefineOptionList("m|mibc", ref _mibcFilePaths, "Mibc file(s) for profile guided optimization"); ;
                 syntax.DefineOption("g", ref _enableDebugInfo, "Emit debugging information");
+                syntax.DefineOption("gdwarf-5", ref _useDwarf5, "Generate source-level debug information with dwarf version 5");
                 syntax.DefineOption("nativelib", ref _nativeLib, "Compile as static or shared library");
                 syntax.DefineOption("exportsfile", ref _exportsFile, "File to write exported method definitions");
                 syntax.DefineOption("dgmllog", ref _dgmlLogFileName, "Save result of dependency analysis as DGML");
@@ -769,7 +771,8 @@ static string ILLinkify(string rootedAssembly)
                 .UseCompilationRoots(compilationRoots)
                 .UseOptimizationMode(_optimizationMode)
                 .UseSecurityMitigationOptions(securityMitigationOptions)
-                .UseDebugInfoProvider(debugInfoProvider);
+                .UseDebugInfoProvider(debugInfoProvider)
+                .UseDwarf5(_useDwarf5);
 
             if (scanResults != null)
             {

From 8cee8faa5becff0a1afc0d8d149fe5f43d675399 Mon Sep 17 00:00:00 2001
From: Dan Moseley <danmose@microsoft.com>
Date: Mon, 24 Jan 2022 00:54:36 -0700
Subject: [PATCH 017/161] Re-enable failing long path test (#64113)

---
 .../System.IO.FileSystem/tests/Directory/CreateDirectory.cs  | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs b/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs
index ae0f89d32da08d..4e53a93a4e03a9 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs
@@ -264,15 +264,16 @@ public void DirectoryLongerThanMaxLongPath_ThrowsPathTooLongException()
             });
         }
 
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/64019")]
         [ConditionalFact(nameof(LongPathsAreNotBlocked), nameof(UsingNewNormalization))]
         [PlatformSpecific(TestPlatforms.Windows)]
         public void DirectoryLongerThanMaxLongPathWithExtendedSyntax_ThrowsException()
         {
             var paths = IOInputs.GetPathsLongerThanMaxLongPath(GetTestFilePath(), useExtendedSyntax: true);
 
+            // Ideally this should be PathTooLongException or DirectoryNotFoundException but on some machines
+            // windows gives us ERROR_INVALID_NAME, producing IOException.
             Assert.All(paths, path =>
-                AssertExtensions.ThrowsAny<PathTooLongException, DirectoryNotFoundException>(() => Create(path)));
+                AssertExtensions.ThrowsAny<PathTooLongException, DirectoryNotFoundException, IOException>(() => Create(path)));
         }
 
         [ConditionalFact(nameof(LongPathsAreNotBlocked), nameof(UsingNewNormalization))]

From f4bfd05ecea3e00b725a71a211501f60a4e863ba Mon Sep 17 00:00:00 2001
From: Maxim Lipnin <v-maxlip@microsoft.com>
Date: Mon, 24 Jan 2022 11:04:22 +0300
Subject: [PATCH 018/161] Port MD4 managed implementation from mono/mono
 (#62074)

Porting MD4 managed implementation from mono/mono (MD4.cs and MD4Managed.cs).

It adds:
- an internal class in the System.Net.Security with a single HashData method for now;
- a set of related MD 4 unit tests to System.Net.Security.Unit.Tests project.
---
 .../src/System.Net.Security.csproj            |   1 +
 .../src/System/Net/Security/MD4.cs            | 256 ++++++++++++++++++
 .../tests/UnitTests/MD4Tests.cs               | 158 +++++++++++
 .../System.Net.Security.Unit.Tests.csproj     |   6 +-
 4 files changed, 420 insertions(+), 1 deletion(-)
 create mode 100644 src/libraries/System.Net.Security/src/System/Net/Security/MD4.cs
 create mode 100644 src/libraries/System.Net.Security/tests/UnitTests/MD4Tests.cs

diff --git a/src/libraries/System.Net.Security/src/System.Net.Security.csproj b/src/libraries/System.Net.Security/src/System.Net.Security.csproj
index 9f90dbd3951f05..047cbdcc98aea9 100644
--- a/src/libraries/System.Net.Security/src/System.Net.Security.csproj
+++ b/src/libraries/System.Net.Security/src/System.Net.Security.csproj
@@ -363,6 +363,7 @@
     <Compile Include="$(CommonPath)Interop\Android\System.Security.Cryptography.Native.Android\Interop.X509.cs"
              Link="Common\Interop\Android\System.Security.Cryptography.Native.Android\Interop.X509.cs" />
     <Compile Include="System\Net\CertificateValidationPal.Android.cs" />
+    <Compile Include="System\Net\Security\MD4.cs" />
     <Compile Include="System\Net\Security\Pal.Android\SafeDeleteSslContext.cs" />
     <Compile Include="System\Net\Security\Pal.Managed\SafeFreeSslCredentials.cs" />
     <Compile Include="System\Net\Security\Pal.Managed\SslProtocolsValidation.cs" />
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/MD4.cs b/src/libraries/System.Net.Security/src/System/Net/Security/MD4.cs
new file mode 100644
index 00000000000000..bdf3547912c911
--- /dev/null
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/MD4.cs
@@ -0,0 +1,256 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+//
+// MD4.cs - Message Digest 4 Abstract class
+//
+// Author:
+//  Sebastien Pouliot (sebastien@xamarin.com)
+//
+// (C) 2003 Motus Technologies Inc. (http://www.motus.com)
+// Copyright 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System.Buffers.Binary;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+
+//
+// This class is a port of the Mono managed implementation of the MD4 algorithm
+// and required to support NTLM in Android only.
+// It's an implementation detail and is not intended to be a public API.
+// Assuming that NTLM would be System.Net.Security, it makes sense to put MD4 here as well.
+//
+namespace System.Net.Security
+{
+    internal sealed class MD4
+    {
+        private const int S11 = 3;
+        private const int S12 = 7;
+        private const int S13 = 11;
+        private const int S14 = 19;
+        private const int S21 = 3;
+        private const int S22 = 5;
+        private const int S23 = 9;
+        private const int S24 = 13;
+        private const int S31 = 3;
+        private const int S32 = 9;
+        private const int S33 = 11;
+        private const int S34 = 15;
+
+        internal static void HashData(ReadOnlySpan<byte> source, Span<byte> destination)
+        {
+            Debug.Assert(destination.Length == 128 >> 3);
+
+            Span<byte> buffer = stackalloc byte[64];
+            buffer.Clear();
+            // Initialize the context
+            Span<uint> state = stackalloc uint[4] { 0x67452301, 0xefcdab89,  0x98badcfe, 0x10325476 };
+            Span<uint> count = stackalloc uint[2] { 0, 0 };
+
+            HashCore(source, state, count, buffer);
+
+            // Save number of bits
+            Span<byte> bits = stackalloc byte[8];
+            Encode(bits, count);
+
+            // Pad out to 56 mod 64
+            uint index = ((count[0] >> 3) & 0x3f);
+            int padLen = (int)((index < 56) ? (56 - index) : (120 - index));
+            Span<byte> padding = stackalloc byte[padLen];
+            padding.Clear();
+            padding[0] = 0x80;
+            HashCore(padding, state, count, buffer);
+
+            // Append length (before padding)
+            HashCore(bits, state, count, buffer);
+
+            // Write state to destination
+            Encode(destination, state);
+        }
+
+        private static void HashCore(ReadOnlySpan<byte> input, Span<uint> state, Span<uint> count, Span<byte> buffer)
+        {
+            // Compute number of bytes mod 64
+            int index = (int)((count[0] >> 3) & 0x3F);
+            // Update number of bits
+            count[0] += (uint)(input.Length << 3);
+            if (count[0] < (input.Length << 3))
+            {
+                count[1]++;
+            }
+
+            count[1] += (uint)(input.Length >> 29);
+
+            int partLen = 64 - index;
+            int i = 0;
+            // Transform as many times as possible.
+            if (input.Length >= partLen)
+            {
+                if (index != 0)
+                {
+                    input.Slice(0, partLen).CopyTo(buffer.Slice(index));
+                    MD4Transform(state, buffer);
+                    index = 0;
+                }
+                else
+                {
+                    partLen  = 0;
+                }
+
+                for (i = partLen; i + 63 < input.Length; i += 64)
+                {
+                    MD4Transform(state, input.Slice(i));
+                }
+            }
+
+            // Buffer remaining input
+            input.Slice(i).CopyTo(buffer.Slice(index));
+        }
+
+        //--- private methods ---------------------------------------------------
+
+        // F, G and H are basic MD4 functions.
+        private static uint F(uint x, uint y, uint z)
+        {
+            return (uint)(((x) & (y)) | ((~x) & (z)));
+        }
+
+        private static uint G(uint x, uint y, uint z)
+        {
+            return (uint)(((x) & (y)) | ((x) & (z)) | ((y) & (z)));
+        }
+
+        private static uint H(uint x, uint y, uint z)
+        {
+            return (uint)((x) ^ (y) ^ (z));
+        }
+
+        // FF, GG and HH are transformations for rounds 1, 2 and 3.
+        // Rotation is separate from addition to prevent recomputation.
+        private static void FF(ref uint a, uint b, uint c, uint d, uint x, byte s)
+        {
+            a += F(b, c, d) + x;
+            a = BitOperations.RotateLeft(a, s);
+        }
+
+        private static void GG(ref uint a, uint b, uint c, uint d, uint x, byte s)
+        {
+            a += G(b, c, d) + x + 0x5a827999;
+            a = BitOperations.RotateLeft(a, s);
+        }
+
+        private static void HH(ref uint a, uint b, uint c, uint d, uint x, byte s)
+        {
+            a += H(b, c, d) + x + 0x6ed9eba1;
+            a = BitOperations.RotateLeft(a, s);
+        }
+
+        private static void Encode(Span<byte> output, Span<uint> input)
+        {
+            for (int i = 0, j = 0; j < output.Length; i++, j += 4)
+            {
+                BinaryPrimitives.WriteUInt32LittleEndian(output.Slice(j), input[i]);
+            }
+        }
+
+        private static void Decode(Span<uint> output, ReadOnlySpan<byte> input)
+        {
+            for (int i = 0, j = 0; i < output.Length; i++, j += 4)
+            {
+                output[i] = BinaryPrimitives.ReadUInt32LittleEndian(input.Slice(j));
+            }
+        }
+
+        private static void MD4Transform(Span<uint> state, ReadOnlySpan<byte> block)
+        {
+            uint a = state[0];
+            uint b = state[1];
+            uint c = state[2];
+            uint d = state[3];
+            Span<uint> x = stackalloc uint[16];
+
+            Decode(x, block);
+
+            // Round 1
+            FF(ref a, b, c, d, x[0], S11); // 1
+            FF(ref d, a, b, c, x[1], S12); // 2
+            FF(ref c, d, a, b, x[2], S13); // 3
+            FF(ref b, c, d, a, x[3], S14); // 4
+            FF(ref a, b, c, d, x[4], S11); // 5
+            FF(ref d, a, b, c, x[5], S12); // 6
+            FF(ref c, d, a, b, x[6], S13); // 7
+            FF(ref b, c, d, a, x[7], S14); // 8
+            FF(ref a, b, c, d, x[8], S11); // 9
+            FF(ref d, a, b, c, x[9], S12); // 10
+            FF(ref c, d, a, b, x[10], S13); // 11
+            FF(ref b, c, d, a, x[11], S14); // 12
+            FF(ref a, b, c, d, x[12], S11); // 13
+            FF(ref d, a, b, c, x[13], S12); // 14
+            FF(ref c, d, a, b, x[14], S13); // 15
+            FF(ref b, c, d, a, x[15], S14); // 16
+
+            // Round 2
+            GG(ref a, b, c, d, x[0], S21); // 17
+            GG(ref d, a, b, c, x[4], S22); // 18
+            GG(ref c, d, a, b, x[8], S23); // 19
+            GG(ref b, c, d, a, x[12], S24); // 20
+            GG(ref a, b, c, d, x[1], S21); // 21
+            GG(ref d, a, b, c, x[5], S22); // 22
+            GG(ref c, d, a, b, x[9], S23); // 23
+            GG(ref b, c, d, a, x[13], S24); // 24
+            GG(ref a, b, c, d, x[2], S21); // 25
+            GG(ref d, a, b, c, x[6], S22); // 26
+            GG(ref c, d, a, b, x[10], S23); // 27
+            GG(ref b, c, d, a, x[14], S24); // 28
+            GG(ref a, b, c, d, x[3], S21); // 29
+            GG(ref d, a, b, c, x[7], S22); // 30
+            GG(ref c, d, a, b, x[11], S23); // 31
+            GG(ref b, c, d, a, x[15], S24); // 32
+
+            HH(ref a, b, c, d, x[0], S31); // 33
+            HH(ref d, a, b, c, x[8], S32); // 34
+            HH(ref c, d, a, b, x[4], S33); // 35
+            HH(ref b, c, d, a, x[12], S34); // 36
+            HH(ref a, b, c, d, x[2], S31); // 37
+            HH(ref d, a, b, c, x[10], S32); // 38
+            HH(ref c, d, a, b, x[6], S33); // 39
+            HH(ref b, c, d, a, x[14], S34); // 40
+            HH(ref a, b, c, d, x[1], S31); // 41
+            HH(ref d, a, b, c, x[9], S32); // 42
+            HH(ref c, d, a, b, x[5], S33); // 43
+            HH(ref b, c, d, a, x[13], S34); // 44
+            HH(ref a, b, c, d, x[3], S31); // 45
+            HH(ref d, a, b, c, x[11], S32); // 46
+            HH(ref c, d, a, b, x[7], S33); // 47
+            HH(ref b, c, d, a, x[15], S34); // 48
+
+            state[0] += a;
+            state[1] += b;
+            state[2] += c;
+            state[3] += d;
+        }
+    }
+}
diff --git a/src/libraries/System.Net.Security/tests/UnitTests/MD4Tests.cs b/src/libraries/System.Net.Security/tests/UnitTests/MD4Tests.cs
new file mode 100644
index 00000000000000..a3667ebb896e54
--- /dev/null
+++ b/src/libraries/System.Net.Security/tests/UnitTests/MD4Tests.cs
@@ -0,0 +1,158 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using System.Net.Security;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace System.Net.Security.Tests
+{
+    public class MD4Tests
+    {
+        // MD4("") = 31d6cfe0d16ae931b73c59d7e0c089c0
+        [Fact]
+        public void TryEncrypt_Empty()
+        {
+            ReadOnlySpan<byte> input = new byte[0];
+            ReadOnlySpan<byte> expected = new byte[] { 0x31, 0xd6, 0xcf, 0xe0, 0xd1, 0x6a, 0xe9, 0x31, 0xb7, 0x3c, 0x59, 0xd7, 0xe0, 0xc0, 0x89, 0xc0 };
+            Verify(input, expected);
+        }
+
+        // // MD4("a") = bde52cb31de33e46245e05fbdbd6fb24
+        [Fact]
+        public void TryEncrypt_SingleLetter()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("a"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xbd, 0xe5, 0x2c, 0xb3, 0x1d, 0xe3, 0x3e, 0x46, 0x24, 0x5e, 0x05, 0xfb, 0xdb, 0xd6, 0xfb, 0x24 };
+            Verify(input, expected);
+        }
+
+        // MD4("abc") = a448017aaf21d8525fc10ae87aa6729d
+        [Fact]
+        public void TryEncrypt_ThreeLetters()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("abc"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xa4, 0x48, 0x01, 0x7a, 0xaf, 0x21, 0xd8, 0x52, 0x5f, 0xc1, 0x0a, 0xe8, 0x7a, 0xa6, 0x72, 0x9d };
+            Verify(input, expected);
+        }
+
+        // MD4("message digest") = d9130a8164549fe818874806e1c7014b
+        [Fact]
+        public void TryEncrypt_Phrase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("message digest"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xd9, 0x13, 0x0a, 0x81, 0x64, 0x54, 0x9f, 0xe8, 0x18, 0x87, 0x48, 0x06, 0xe1, 0xc7, 0x01, 0x4b };
+            Verify(input, expected);
+        }
+
+        // MD4("abcdefghijklmnopqrstuvwxyz") = d79e1c308aa5bbcdeea8ed63df412da9
+        [Fact]
+        public void TryEncrypt_AlphabetInLowercase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("abcdefghijklmnopqrstuvwxyz"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xd7, 0x9e, 0x1c, 0x30, 0x8a, 0xa5, 0xbb, 0xcd, 0xee, 0xa8, 0xed, 0x63, 0xdf, 0x41, 0x2d, 0xa9 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") =	043f8582f241db351ce627e153e7f0e4
+        [Fact]
+        public void TryEncrypt_AlphabetInUpperLowerCasesAndNumbers()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>((Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")));
+            ReadOnlySpan<byte> expected = new byte[] { 0x04, 0x3f, 0x85, 0x82, 0xf2, 0x41, 0xdb, 0x35, 0x1c, 0xe6, 0x27, 0xe1, 0x53, 0xe7, 0xf0, 0xe4 };
+            Verify(input, expected);
+        }
+
+        // MD4("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = e33b4ddc9c38f2199c3e7b164fcc0536
+        [Fact]
+        public void TryEncrypt_RepeatedSequenceOfNumbers()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("12345678901234567890123456789012345678901234567890123456789012345678901234567890"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xe3, 0x3b, 0x4d, 0xdc, 0x9c, 0x38, 0xf2, 0x19, 0x9c, 0x3e, 0x7b, 0x16, 0x4f, 0xcc, 0x05, 0x36 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012") = 14fdf2056bf88b3491c385d8ac4f48e6
+        // 55 bytes (padLen == 56 - 55 => 1)
+        [Fact]
+        public void TryEncrypt_55bytes_HitsEdgeCaseForPaddingLength()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012"));
+            ReadOnlySpan<byte> expected = new byte[] { 0x14, 0xfd, 0xf2, 0x05, 0x6b, 0xf8, 0x8b, 0x34, 0x91, 0xc3, 0x85, 0xd8, 0xac, 0x4f, 0x48, 0xe6 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123") = db837dbb6098a50a2d3974bc1cc76133
+        // 56 bytes (padLen == 120 - 56 => 64)
+        [Fact]
+        public void TryEncrypt_56bytes_HitsEdgeCaseForPaddingLength()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xdb, 0x83, 0x7d, 0xbb, 0x60, 0x98, 0xa5, 0x0a, 0x2d, 0x39, 0x74, 0xbc, 0x1c, 0xc7, 0x61, 0x33 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890") = ce64c40ecfbe896462f3c1a925884624
+        [Fact]
+        public void TryEncrypt_63bytes_HitsEdgeCase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xce, 0x64, 0xc4, 0x0e, 0xcf, 0xbe, 0x89, 0x64, 0x62, 0xf3, 0xc1, 0xa9, 0x25, 0x88, 0x46, 0x24 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901") = 4b0e77758d2ede1eb21d267d492ae70b
+        [Fact]
+        public void TryEncrypt_64bytes_HitsEdgeCase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901"));
+            ReadOnlySpan<byte> expected = new byte[] { 0x4b, 0x0e, 0x77, 0x75, 0x8d, 0x2e, 0xde, 0x1e, 0xb2, 0x1d, 0x26, 0x7d, 0x49, 0x2a, 0xe7, 0x0b };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789012") = 3b46ad159b3fd800d254e3c4cc71fe36
+        [Fact]
+        public void TryEncrypt_65bytes_HitsEdgeCase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789012"));
+            ReadOnlySpan<byte> expected = new byte[] { 0x3b, 0x46, 0xad, 0x15, 0x9b, 0x3f, 0xd8, 0x00, 0xd2, 0x54, 0xe3, 0xc4, 0xcc, 0x71, 0xfe, 0x36 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890") = a3e23048e4ade47a0f00fa8aed2a0248
+        [Fact]
+        public void TryEncrypt_127bytes_HitsEdgeCase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xa3, 0xe2, 0x30, 0x48, 0xe4, 0xad, 0xe4, 0x7a, 0x0f, 0x00, 0xfa, 0x8a, 0xed, 0x2a, 0x02, 0x48 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901") = de49da96c105be37b242f2bee86c4759
+        [Fact]
+        public void TryEncrypt_128bytes_HitsEdgeCase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xde, 0x49, 0xda, 0x96, 0xc1, 0x05, 0xbe, 0x37, 0xb2, 0x42, 0xf2, 0xbe, 0xe8, 0x6c, 0x47, 0x59 };
+            Verify(input, expected);
+        }
+
+        // MD4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789012") = a6c10c320f8827d08248a2d8b124b040
+        [Fact]
+        public void TryEncrypt_129bytes_HitsEdgeCase()
+        {
+            ReadOnlySpan<byte> input = new ReadOnlySpan<byte>(Encoding.Default.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789012"));
+            ReadOnlySpan<byte> expected = new byte[] { 0xa6, 0xc1, 0x0c, 0x32, 0x0f, 0x88, 0x27, 0xd0, 0x82, 0x48, 0xa2, 0xd8, 0xb1, 0x24, 0xb0, 0x40 };
+            Verify(input, expected);
+        }
+
+        private void Verify(ReadOnlySpan<byte> input, ReadOnlySpan<byte> expected)
+        {
+            Span<byte> output = stackalloc byte[expected.Length];
+            MD4.HashData(input, output);
+            Assert.Equal(expected.ToArray(), output.ToArray());
+        }
+    }
+}
diff --git a/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj b/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj
index da4dde4e192b90..28b3f81b02b3d7 100644
--- a/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj
+++ b/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj
@@ -10,13 +10,17 @@
     <NoWarn>436</NoWarn>
     <!-- Disable: CLSCompliant attribute is not needed -->
     <NoWarn>$(NoWarn);3021</NoWarn>
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)-Browser;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-iOS</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)-Browser;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-iOS;$(NetCoreAppCurrent)-Android</TargetFrameworks>
     <Nullable>annotations</Nullable>
     <IgnoreForCI Condition="'$(TargetOS)' == 'Browser'">true</IgnoreForCI>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetsAndroid)' == 'true'">
+    <Compile Include="MD4Tests.cs" />
+    <Compile Include="..\..\src\System\Net\Security\MD4.cs" />
+  </ItemGroup>
   <ItemGroup Condition="'$(TargetsBrowser)' != 'true'">
     <Compile Include="SslApplicationProtocolTests.cs" />
     <Compile Include="SslAuthenticationOptionsTests.cs" />

From bb5ca4c9380196bcce4fc62ce5e6c9d52f001b2c Mon Sep 17 00:00:00 2001
From: Peter Sollich <petersol@microsoft.com>
Date: Mon, 24 Jan 2022 09:24:38 +0100
Subject: [PATCH 019/161] Fix one source of perf regression in GCHeap::Alloc.
 This impacts the System.Collections.CtorFromCollectionNonGeneric<Int32>
 family of benchmarks. (#64091)

These benchmarks manage to make GCHeap::Alloc into a hotspot, so the call to IsHeapPointer() at the end matters for performance.
---
 src/coreclr/gc/gc.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp
index e270bcdc91ee47..9ab892a5ad338d 100644
--- a/src/coreclr/gc/gc.cpp
+++ b/src/coreclr/gc/gc.cpp
@@ -44081,12 +44081,8 @@ GCHeap::Alloc(gc_alloc_context* context, size_t size, uint32_t flags REQD_ALIGN_
     }
 
     CHECK_ALLOC_AND_POSSIBLY_REGISTER_FOR_FINALIZATION(newAlloc, size, flags & GC_ALLOC_FINALIZE);
-
 #ifdef USE_REGIONS
-    if (!IsHeapPointer (newAlloc))
-    {
-        GCToOSInterface::DebugBreak();
-    }
+    assert (IsHeapPointer (newAlloc));
 #endif //USE_REGIONS
 
     return newAlloc;

From 73bf54ffa4c7ca3e9ff471456ed57a719b66a847 Mon Sep 17 00:00:00 2001
From: Wraith <wraith2@gmail.com>
Date: Mon, 24 Jan 2022 08:53:39 +0000
Subject: [PATCH 020/161] Add blsr (#63545)

---
 src/coreclr/jit/emitxarch.h      |   2 +-
 src/coreclr/jit/hwintrinsic.h    |  19 ++++++
 src/coreclr/jit/instrsxarch.h    |   2 +-
 src/coreclr/jit/lower.cpp        |  42 +++++++------
 src/coreclr/jit/lower.h          |   4 +-
 src/coreclr/jit/lowerarmarch.cpp |  16 +++++
 src/coreclr/jit/lowerxarch.cpp   | 105 +++++++++++++++++++++++++++++++
 7 files changed, 168 insertions(+), 22 deletions(-)

diff --git a/src/coreclr/jit/emitxarch.h b/src/coreclr/jit/emitxarch.h
index d6ed324deb242a..5cef7d5aa12f25 100644
--- a/src/coreclr/jit/emitxarch.h
+++ b/src/coreclr/jit/emitxarch.h
@@ -193,7 +193,7 @@ bool IsDstDstSrcAVXInstruction(instruction ins);
 bool IsDstSrcSrcAVXInstruction(instruction ins);
 bool HasRegularWideForm(instruction ins);
 bool HasRegularWideImmediateForm(instruction ins);
-bool DoesWriteZeroFlag(instruction ins);
+static bool DoesWriteZeroFlag(instruction ins);
 bool DoesWriteSignFlag(instruction ins);
 bool DoesResetOverflowAndCarryFlags(instruction ins);
 bool IsFlagsAlwaysModified(instrDesc* id);
diff --git a/src/coreclr/jit/hwintrinsic.h b/src/coreclr/jit/hwintrinsic.h
index 43bd543c599f1d..4551ed9e4e1ce1 100644
--- a/src/coreclr/jit/hwintrinsic.h
+++ b/src/coreclr/jit/hwintrinsic.h
@@ -577,6 +577,25 @@ struct HWIntrinsicInfo
         return lookup(id).ins[type - TYP_BYTE];
     }
 
+    static instruction lookupIns(GenTreeHWIntrinsic* intrinsicNode)
+    {
+        assert(intrinsicNode != nullptr);
+
+        NamedIntrinsic intrinsic = intrinsicNode->GetHWIntrinsicId();
+        var_types      type      = TYP_UNKNOWN;
+
+        if (lookupCategory(intrinsic) == HW_Category_Scalar)
+        {
+            type = intrinsicNode->TypeGet();
+        }
+        else
+        {
+            type = intrinsicNode->GetSimdBaseType();
+        }
+
+        return lookupIns(intrinsic, type);
+    }
+
     static HWIntrinsicCategory lookupCategory(NamedIntrinsic id)
     {
         return lookup(id).category;
diff --git a/src/coreclr/jit/instrsxarch.h b/src/coreclr/jit/instrsxarch.h
index 458f919fe27935..08d4c4a8c8675d 100644
--- a/src/coreclr/jit/instrsxarch.h
+++ b/src/coreclr/jit/instrsxarch.h
@@ -595,7 +595,7 @@ INST3(FIRST_BMI_INSTRUCTION, "FIRST_BMI_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE
 INST3(andn,             "andn",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF2),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Logical AND NOT
 INST3(blsi,             "blsi",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF3),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Extract Lowest Set Isolated Bit
 INST3(blsmsk,           "blsmsk",           IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF3),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Get Mask Up to Lowest Set Bit
-INST3(blsr,             "blsr",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF3),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Reset Lowest Set Bit
+INST3(blsr,             "blsr",             IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF3),                             Resets_OF      | Writes_SF     | Writes_ZF     | Undefined_AF  | Undefined_PF  | Writes_CF     | INS_Flags_IsDstDstSrcAVXInstruction)    // Reset Lowest Set Bit
 INST3(bextr,            "bextr",            IUM_WR, BAD_CODE,     BAD_CODE,     SSE38(0xF7),                             INS_Flags_IsDstDstSrcAVXInstruction)    // Bit Field Extract
 
 // BMI2
diff --git a/src/coreclr/jit/lower.cpp b/src/coreclr/jit/lower.cpp
index f29baa320940d7..d19e1460c4a035 100644
--- a/src/coreclr/jit/lower.cpp
+++ b/src/coreclr/jit/lower.cpp
@@ -139,7 +139,7 @@ GenTree* Lowering::LowerNode(GenTree* node)
         case GT_AND:
         case GT_OR:
         case GT_XOR:
-            return LowerBinaryArithmetic(node->AsOp());
+            return LowerBinaryArithmeticCommon(node->AsOp());
 
         case GT_MUL:
         case GT_MULHI:
@@ -2708,10 +2708,16 @@ GenTree* Lowering::OptimizeConstCompare(GenTree* cmp)
 
         if (op2->IsIntegralConst(0) && (op1->gtNext == op2) && (op2->gtNext == cmp) &&
 #ifdef TARGET_XARCH
-            op1->OperIs(GT_AND, GT_OR, GT_XOR, GT_ADD, GT_SUB, GT_NEG))
+            (op1->OperIs(GT_AND, GT_OR, GT_XOR, GT_ADD, GT_SUB, GT_NEG)
+#ifdef FEATURE_HW_INTRINSICS
+             || (op1->OperIs(GT_HWINTRINSIC) &&
+                 emitter::DoesWriteZeroFlag(HWIntrinsicInfo::lookupIns(op1->AsHWIntrinsic())))
+#endif // FEATURE_HW_INTRINSICS
+                 )
 #else // TARGET_ARM64
-            op1->OperIs(GT_AND, GT_ADD, GT_SUB))
+            op1->OperIs(GT_AND, GT_ADD, GT_SUB)
 #endif
+                )
         {
             op1->gtFlags |= GTF_SET_FLAGS;
             op1->SetUnusedValue();
@@ -5117,7 +5123,7 @@ GenTree* Lowering::LowerAdd(GenTreeOp* node)
 }
 
 //------------------------------------------------------------------------
-// LowerBinaryArithmetic: lowers the given binary arithmetic node.
+// LowerBinaryArithmeticCommon: lowers the given binary arithmetic node.
 //
 // Recognizes opportunities for using target-independent "combined" nodes
 // (currently AND_NOT on ARMArch). Performs containment checks.
@@ -5128,41 +5134,39 @@ GenTree* Lowering::LowerAdd(GenTreeOp* node)
 // Returns:
 //    The next node to lower.
 //
-GenTree* Lowering::LowerBinaryArithmetic(GenTreeOp* node)
+GenTree* Lowering::LowerBinaryArithmeticCommon(GenTreeOp* binOp)
 {
     // TODO-CQ-XArch: support BMI2 "andn" in codegen and condition
     // this logic on the support for the instruction set on XArch.
     CLANG_FORMAT_COMMENT_ANCHOR;
 
 #ifdef TARGET_ARMARCH
-    if (comp->opts.OptimizationEnabled() && node->OperIs(GT_AND))
+    if (comp->opts.OptimizationEnabled() && binOp->OperIs(GT_AND))
     {
         GenTree* opNode  = nullptr;
         GenTree* notNode = nullptr;
-        if (node->gtGetOp1()->OperIs(GT_NOT))
+        if (binOp->gtGetOp1()->OperIs(GT_NOT))
         {
-            notNode = node->gtGetOp1();
-            opNode  = node->gtGetOp2();
+            notNode = binOp->gtGetOp1();
+            opNode  = binOp->gtGetOp2();
         }
-        else if (node->gtGetOp2()->OperIs(GT_NOT))
+        else if (binOp->gtGetOp2()->OperIs(GT_NOT))
         {
-            notNode = node->gtGetOp2();
-            opNode  = node->gtGetOp1();
+            notNode = binOp->gtGetOp2();
+            opNode  = binOp->gtGetOp1();
         }
 
         if (notNode != nullptr)
         {
-            node->gtOp1 = opNode;
-            node->gtOp2 = notNode->AsUnOp()->gtGetOp1();
-            node->ChangeOper(GT_AND_NOT);
+            binOp->gtOp1 = opNode;
+            binOp->gtOp2 = notNode->AsUnOp()->gtGetOp1();
+            binOp->ChangeOper(GT_AND_NOT);
             BlockRange().Remove(notNode);
         }
     }
-#endif // TARGET_ARMARCH
-
-    ContainCheckBinary(node);
+#endif
 
-    return node->gtNext;
+    return LowerBinaryArithmetic(binOp);
 }
 
 //------------------------------------------------------------------------
diff --git a/src/coreclr/jit/lower.h b/src/coreclr/jit/lower.h
index 92a4ef43f2370a..624cc1372dc5a9 100644
--- a/src/coreclr/jit/lower.h
+++ b/src/coreclr/jit/lower.h
@@ -297,7 +297,8 @@ class Lowering final : public Phase
     void LowerStoreIndir(GenTreeStoreInd* node);
     GenTree* LowerAdd(GenTreeOp* node);
     GenTree* LowerMul(GenTreeOp* mul);
-    GenTree* LowerBinaryArithmetic(GenTreeOp* node);
+    GenTree* LowerBinaryArithmeticCommon(GenTreeOp* binOp);
+    GenTree* LowerBinaryArithmetic(GenTreeOp* binOp);
     bool LowerUnsignedDivOrMod(GenTreeOp* divMod);
     GenTree* LowerConstIntDivOrMod(GenTree* node);
     GenTree* LowerSignedDivOrMod(GenTree* node);
@@ -343,6 +344,7 @@ class Lowering final : public Phase
     void LowerHWIntrinsicToScalar(GenTreeHWIntrinsic* node);
     void LowerHWIntrinsicGetElement(GenTreeHWIntrinsic* node);
     void LowerHWIntrinsicWithElement(GenTreeHWIntrinsic* node);
+    GenTree* TryLowerAndOpToResetLowestSetBit(GenTreeOp* binOp);
 #elif defined(TARGET_ARM64)
     bool IsValidConstForMovImm(GenTreeHWIntrinsic* node);
     void LowerHWIntrinsicFusedMultiplyAddScalar(GenTreeHWIntrinsic* node);
diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp
index e1812d7e8df6fa..67e1269dfd429a 100644
--- a/src/coreclr/jit/lowerarmarch.cpp
+++ b/src/coreclr/jit/lowerarmarch.cpp
@@ -281,6 +281,22 @@ GenTree* Lowering::LowerMul(GenTreeOp* mul)
     return mul->gtNext;
 }
 
+//------------------------------------------------------------------------
+// LowerBinaryArithmetic: lowers the given binary arithmetic node.
+//
+// Arguments:
+//    node - the arithmetic node to lower
+//
+// Returns:
+//    The next node to lower.
+//
+GenTree* Lowering::LowerBinaryArithmetic(GenTreeOp* binOp)
+{
+    ContainCheckBinary(binOp);
+
+    return binOp->gtNext;
+}
+
 //------------------------------------------------------------------------
 // LowerBlockStore: Lower a block store node
 //
diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp
index 413e4ba74a6a48..a6b0ceb91ba955 100644
--- a/src/coreclr/jit/lowerxarch.cpp
+++ b/src/coreclr/jit/lowerxarch.cpp
@@ -159,6 +159,33 @@ GenTree* Lowering::LowerMul(GenTreeOp* mul)
     return mul->gtNext;
 }
 
+//------------------------------------------------------------------------
+// LowerBinaryArithmetic: lowers the given binary arithmetic node.
+//
+// Arguments:
+//    node - the arithmetic node to lower
+//
+// Returns:
+//    The next node to lower.
+//
+GenTree* Lowering::LowerBinaryArithmetic(GenTreeOp* binOp)
+{
+#ifdef FEATURE_HW_INTRINSICS
+    if (comp->opts.OptimizationEnabled() && binOp->OperIs(GT_AND) && varTypeIsIntegral(binOp))
+    {
+        GenTree* blsrNode = TryLowerAndOpToResetLowestSetBit(binOp);
+        if (blsrNode != nullptr)
+        {
+            return blsrNode->gtNext;
+        }
+    }
+#endif
+
+    ContainCheckBinary(binOp);
+
+    return binOp->gtNext;
+}
+
 //------------------------------------------------------------------------
 // LowerBlockStore: Lower a block store node
 //
@@ -3697,6 +3724,84 @@ void Lowering::LowerHWIntrinsicToScalar(GenTreeHWIntrinsic* node)
         LowerNode(cast);
     }
 }
+
+//----------------------------------------------------------------------------------------------
+// Lowering::TryLowerAndOpToResetLowestSetBit: Lowers a tree AND(X, ADD(X, -1) to HWIntrinsic::ResetLowestSetBit
+//
+// Arguments:
+//    andNode - GT_AND node of integral type
+//
+// Return Value:
+//    Returns the replacement node if one is created else nullptr indicating no replacement
+//
+GenTree* Lowering::TryLowerAndOpToResetLowestSetBit(GenTreeOp* andNode)
+{
+    assert(andNode->OperIs(GT_AND) && varTypeIsIntegral(andNode));
+
+    GenTree* op1 = andNode->gtGetOp1();
+    if (!op1->OperIs(GT_LCL_VAR) || comp->lvaGetDesc(op1->AsLclVar())->IsAddressExposed())
+    {
+        return nullptr;
+    }
+
+    GenTree* op2 = andNode->gtGetOp2();
+    if (!op2->OperIs(GT_ADD))
+    {
+        return nullptr;
+    }
+
+    GenTree* addOp2 = op2->gtGetOp2();
+    if (!addOp2->IsIntegralConst(-1))
+    {
+        return nullptr;
+    }
+
+    GenTree* addOp1 = op2->gtGetOp1();
+    if (!addOp1->OperIs(GT_LCL_VAR) || (addOp1->AsLclVar()->GetLclNum() != op1->AsLclVar()->GetLclNum()))
+    {
+        return nullptr;
+    }
+
+    NamedIntrinsic intrinsic;
+    if (op1->TypeIs(TYP_LONG) && comp->compOpportunisticallyDependsOn(InstructionSet_BMI1_X64))
+    {
+        intrinsic = NamedIntrinsic::NI_BMI1_X64_ResetLowestSetBit;
+    }
+    else if (comp->compOpportunisticallyDependsOn(InstructionSet_BMI1))
+    {
+        intrinsic = NamedIntrinsic::NI_BMI1_ResetLowestSetBit;
+    }
+    else
+    {
+        return nullptr;
+    }
+
+    LIR::Use use;
+    if (!BlockRange().TryGetUse(andNode, &use))
+    {
+        return nullptr;
+    }
+
+    GenTreeHWIntrinsic* blsrNode = comp->gtNewScalarHWIntrinsicNode(andNode->TypeGet(), op1, intrinsic);
+
+    JITDUMP("Lower: optimize AND(X, ADD(X, -1))\n");
+    DISPNODE(andNode);
+    JITDUMP("to:\n");
+    DISPNODE(blsrNode);
+
+    use.ReplaceWith(blsrNode);
+
+    BlockRange().InsertBefore(andNode, blsrNode);
+    BlockRange().Remove(andNode);
+    BlockRange().Remove(op2);
+    BlockRange().Remove(addOp1);
+    BlockRange().Remove(addOp2);
+
+    ContainCheckHWIntrinsic(blsrNode);
+
+    return blsrNode;
+}
+
 #endif // FEATURE_HW_INTRINSICS
 
 //----------------------------------------------------------------------------------------------

From 85b144a0317dd1ae2b901205434fae02089723a8 Mon Sep 17 00:00:00 2001
From: Carlos Sanchez <1175054+carlossanlop@users.noreply.github.com>
Date: Mon, 24 Jan 2022 00:54:11 -0800
Subject: [PATCH 021/161]  Fix FileSystemAclExtensions.Create when passing a
 null FileSecurity (#61297)

* Make FileSecurity parameter nullable.

* Add missing ArgumentException message for FileMode.Append.

* Refactor tests to ensure FileSecurity is tested with all FileMode and FileSystemRights combinations. Separate special cases.

* Remove exception that throws when FileSecurity is null.
Ensure we have logic that can create a FileHandle when FileSecurity is null.
Fix bug where FileShare.Inheritable causes IOException because it is being unexpectedly passed to the P/Invoke (it should just be saved in the SECURITY_ATTRIBUTES struct).
Add documentation to mention this parameter as optional.
Ensure all exceptions match exactly what we have in .NET Framework, with simpler logic.

* Address suggestions

Co-authored-by: carlossanlop <carlossanlop@users.noreply.github.com>
---
 .../ref/System.IO.FileSystem.AccessControl.cs |   2 +-
 .../src/Resources/Strings.resx                |   3 +
 .../src/System/IO/FileSystemAclExtensions.cs  |  99 ++++-
 .../tests/FileSystemAclExtensionsTests.cs     | 416 +++++++++++-------
 4 files changed, 333 insertions(+), 187 deletions(-)

diff --git a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.cs b/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.cs
index 64455bbc92ccb6..ae5a0e9562c7d3 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.cs
+++ b/src/libraries/System.IO.FileSystem.AccessControl/ref/System.IO.FileSystem.AccessControl.cs
@@ -9,7 +9,7 @@ namespace System.IO
     public static partial class FileSystemAclExtensions
     {
         public static void Create(this System.IO.DirectoryInfo directoryInfo, System.Security.AccessControl.DirectorySecurity directorySecurity) { }
-        public static System.IO.FileStream Create(this System.IO.FileInfo fileInfo, System.IO.FileMode mode, System.Security.AccessControl.FileSystemRights rights, System.IO.FileShare share, int bufferSize, System.IO.FileOptions options, System.Security.AccessControl.FileSecurity fileSecurity) { throw null; }
+        public static System.IO.FileStream Create(this System.IO.FileInfo fileInfo, System.IO.FileMode mode, System.Security.AccessControl.FileSystemRights rights, System.IO.FileShare share, int bufferSize, System.IO.FileOptions options, System.Security.AccessControl.FileSecurity? fileSecurity) { throw null; }
         public static System.IO.DirectoryInfo CreateDirectory(this System.Security.AccessControl.DirectorySecurity directorySecurity, string path) { throw null; }
         public static System.Security.AccessControl.DirectorySecurity GetAccessControl(this System.IO.DirectoryInfo directoryInfo) { throw null; }
         public static System.Security.AccessControl.DirectorySecurity GetAccessControl(this System.IO.DirectoryInfo directoryInfo, System.Security.AccessControl.AccessControlSections includeSections) { throw null; }
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx b/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx
index d71dfd08146e4d..5b24a6296c36d0 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx
@@ -122,6 +122,9 @@
   <data name="Arg_MustBeIdentityReferenceType" xml:space="preserve">
     <value>Type must be an IdentityReference, such as NTAccount or SecurityIdentifier.</value>
   </data>
+  <data name="Argument_InvalidAppendMode" xml:space="preserve">
+    <value>Append access can be requested only in write-only mode.</value>
+  </data>
   <data name="Argument_InvalidEnumValue" xml:space="preserve">
     <value>The value '{0}' is not valid for this usage of the type {1}.</value>
   </data>
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs b/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs
index 51b3f926ba5196..c47f9e255dc91c 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs
+++ b/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs
@@ -159,10 +159,10 @@ public static void Create(this DirectoryInfo directoryInfo, DirectorySecurity di
         /// <param name="share">One of the enumeration values for controlling the kind of access other FileStream objects can have to the same file.</param>
         /// <param name="bufferSize">The number of bytes buffered for reads and writes to the file.</param>
         /// <param name="options">One of the enumeration values that describes how to create or overwrite the file.</param>
-        /// <param name="fileSecurity">An object that determines the access control and audit security for the file.</param>
+        /// <param name="fileSecurity">An optional object that determines the access control and audit security for the file.</param>
         /// <returns>A file stream for the newly created file.</returns>
         /// <exception cref="ArgumentException">The <paramref name="rights" /> and <paramref name="mode" /> combination is invalid.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="fileInfo" /> or <paramref name="fileSecurity" /> is <see langword="null" />.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="fileInfo" /> is <see langword="null" />.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="mode" /> or <paramref name="share" /> are out of their legal enum range.
         ///-or-
         /// <paramref name="bufferSize" /> is not a positive number.</exception>
@@ -170,18 +170,13 @@ public static void Create(this DirectoryInfo directoryInfo, DirectorySecurity di
         /// <exception cref="IOException">An I/O error occurs.</exception>
         /// <exception cref="UnauthorizedAccessException">Access to the path is denied.</exception>
         /// <remarks>This extension method was added to .NET Core to bring the functionality that was provided by the `System.IO.FileStream.#ctor(System.String,System.IO.FileMode,System.Security.AccessControl.FileSystemRights,System.IO.FileShare,System.Int32,System.IO.FileOptions,System.Security.AccessControl.FileSecurity)` .NET Framework constructor.</remarks>
-        public static FileStream Create(this FileInfo fileInfo, FileMode mode, FileSystemRights rights, FileShare share, int bufferSize, FileOptions options, FileSecurity fileSecurity)
+        public static FileStream Create(this FileInfo fileInfo, FileMode mode, FileSystemRights rights, FileShare share, int bufferSize, FileOptions options, FileSecurity? fileSecurity)
         {
             if (fileInfo == null)
             {
                 throw new ArgumentNullException(nameof(fileInfo));
             }
 
-            if (fileSecurity == null)
-            {
-                throw new ArgumentNullException(nameof(fileSecurity));
-            }
-
             // don't include inheritable in our bounds check for share
             FileShare tempshare = share & ~FileShare.Inheritable;
 
@@ -200,18 +195,33 @@ public static FileStream Create(this FileInfo fileInfo, FileMode mode, FileSyste
                 throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
             }
 
-            // Do not allow using combinations of non-writing file system rights with writing file modes
+            // Do not combine writing modes with exclusively read rights
+            // Write contains AppendData, WriteAttributes, WriteData and WriteExtendedAttributes
             if ((rights & FileSystemRights.Write) == 0 &&
                 (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append))
             {
                 throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndFileSystemRightsCombo, mode, rights));
             }
 
+            // Additionally, append is disallowed if any read rights are provided
+            // ReadAndExecute contains ExecuteFile, ReadAttributes, ReadData, ReadExtendedAttributes and ReadPermissions
+            if ((rights & FileSystemRights.ReadAndExecute) != 0 && mode == FileMode.Append)
+            {
+                throw new ArgumentException(SR.Argument_InvalidAppendMode);
+            }
+
+            // Cannot truncate unless all of the write rights are provided
+            // Write contains AppendData, WriteAttributes, WriteData and WriteExtendedAttributes
+            if (mode == FileMode.Truncate && (rights & FileSystemRights.Write) != FileSystemRights.Write)
+            {
+                throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndFileSystemRightsCombo, mode, rights));
+            }
+
             SafeFileHandle handle = CreateFileHandle(fileInfo.FullName, mode, rights, share, options, fileSecurity);
 
             try
             {
-                return new FileStream(handle, GetFileStreamFileAccess(rights), bufferSize, (options & FileOptions.Asynchronous) != 0);
+                return new FileStream(handle, GetFileAccessFromRights(rights), bufferSize, (options & FileOptions.Asynchronous) != 0);
             }
             catch
             {
@@ -258,23 +268,48 @@ public static DirectoryInfo CreateDirectory(this DirectorySecurity directorySecu
 
         // In the context of a FileStream, the only ACCESS_MASK ACE rights we care about are reading/writing data and the generic read/write rights.
         // See: https://docs.microsoft.com/en-us/windows/win32/secauthz/access-mask
-        private static FileAccess GetFileStreamFileAccess(FileSystemRights rights)
+        private static FileAccess GetFileAccessFromRights(FileSystemRights rights)
         {
             FileAccess access = 0;
-            if ((rights & FileSystemRights.ReadData) != 0 || ((int)rights & Interop.Kernel32.GenericOperations.GENERIC_READ) != 0)
+
+            if ((rights & FileSystemRights.FullControl) != 0 ||
+                (rights & FileSystemRights.Modify) != 0)
+            {
+                return FileAccess.ReadWrite;
+            }
+
+            if ((rights & FileSystemRights.ReadData) != 0 || // Same as ListDirectory
+                (rights & FileSystemRights.ReadExtendedAttributes) != 0 ||
+                (rights & FileSystemRights.ExecuteFile) != 0 || // Same as Traverse
+                (rights & FileSystemRights.ReadAttributes) != 0 ||
+                (rights & FileSystemRights.ReadPermissions) != 0 ||
+                (rights & FileSystemRights.TakeOwnership) != 0 ||
+                ((int)rights & Interop.Kernel32.GenericOperations.GENERIC_READ) != 0)
             {
                 access = FileAccess.Read;
             }
 
-            if ((rights & FileSystemRights.WriteData) != 0 || ((int)rights & Interop.Kernel32.GenericOperations.GENERIC_WRITE) != 0)
+            if ((rights & FileSystemRights.AppendData) != 0 || // Same as CreateDirectories
+                (rights & FileSystemRights.ChangePermissions) != 0 ||
+                (rights & FileSystemRights.Delete) != 0 ||
+                (rights & FileSystemRights.DeleteSubdirectoriesAndFiles) != 0 ||
+                (rights & FileSystemRights.WriteAttributes) != 0 ||
+                (rights & FileSystemRights.WriteData) != 0 || // Same as CreateFiles
+                (rights & FileSystemRights.WriteExtendedAttributes) != 0 ||
+                ((int)rights & Interop.Kernel32.GenericOperations.GENERIC_WRITE) != 0)
+            {
+                access |= FileAccess.Write;
+            }
+
+            if (access == 0)
             {
-                access = access == FileAccess.Read ? FileAccess.ReadWrite : FileAccess.Write;
+                throw new ArgumentOutOfRangeException(nameof(rights));
             }
 
             return access;
         }
 
-        private static unsafe SafeFileHandle CreateFileHandle(string fullPath, FileMode mode, FileSystemRights rights, FileShare share, FileOptions options, FileSecurity security)
+        private static unsafe SafeFileHandle CreateFileHandle(string fullPath, FileMode mode, FileSystemRights rights, FileShare share, FileOptions options, FileSecurity? security)
         {
             Debug.Assert(fullPath != null);
 
@@ -291,23 +326,39 @@ private static unsafe SafeFileHandle CreateFileHandle(string fullPath, FileMode
 
             SafeFileHandle handle;
 
-            fixed (byte* pSecurityDescriptor = security.GetSecurityDescriptorBinaryForm())
+            var secAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES
             {
-                var secAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES
+                nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES),
+                bInheritHandle = ((share & FileShare.Inheritable) != 0) ? Interop.BOOL.TRUE : Interop.BOOL.FALSE,
+            };
+
+            if (security != null)
+            {
+                fixed (byte* pSecurityDescriptor = security.GetSecurityDescriptorBinaryForm())
                 {
-                    nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES),
-                    bInheritHandle = ((share & FileShare.Inheritable) != 0) ? Interop.BOOL.TRUE : Interop.BOOL.FALSE,
-                    lpSecurityDescriptor = (IntPtr)pSecurityDescriptor
-                };
+                    secAttrs.lpSecurityDescriptor = (IntPtr)pSecurityDescriptor;
+                    handle = CreateFileHandleInternal(fullPath, mode, rights, share, flagsAndAttributes, &secAttrs);
+                }
+            }
+            else
+            {
+                handle = CreateFileHandleInternal(fullPath, mode, rights, share, flagsAndAttributes, &secAttrs);
+            }
+
+            return handle;
 
+            static unsafe SafeFileHandle CreateFileHandleInternal(string fullPath, FileMode mode, FileSystemRights rights, FileShare share, int flagsAndAttributes, Interop.Kernel32.SECURITY_ATTRIBUTES* secAttrs)
+            {
+                SafeFileHandle handle;
                 using (DisableMediaInsertionPrompt.Create())
                 {
-                    handle = Interop.Kernel32.CreateFile(fullPath, (int)rights, share, &secAttrs, mode, flagsAndAttributes, IntPtr.Zero);
+                    // The Inheritable bit is only set in the SECURITY_ATTRIBUTES struct,
+                    // and should not be passed to the CreateFile P/Invoke.
+                    handle = Interop.Kernel32.CreateFile(fullPath, (int)rights, (share & ~FileShare.Inheritable), secAttrs, mode, flagsAndAttributes, IntPtr.Zero);
                     ValidateFileHandle(handle, fullPath);
                 }
+                return handle;
             }
-
-            return handle;
         }
 
         private static void ValidateFileHandle(SafeFileHandle handle, string fullPath)
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs b/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs
index 22f2e6ffdd09cd..80eb1805310b5b 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs
+++ b/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs
@@ -196,7 +196,7 @@ public void DirectoryInfo_Create_NotFound()
             var dirInfo = new DirectoryInfo(dirPath);
             var security = new DirectorySecurity();
             // Fails because the DirectorySecurity lacks any rights to create parent folder
-            Assert.Throws<UnauthorizedAccessException>(() =>  CreateDirectoryWithSecurity(dirInfo, security));
+            Assert.Throws<UnauthorizedAccessException>(() => CreateDirectoryWithSecurity(dirInfo, security));
         }
 
         [Fact]
@@ -284,156 +284,196 @@ public void FileInfo_Create_NullFileInfo()
         {
             FileInfo info = null;
             var security = new FileSecurity();
-
             Assert.Throws<ArgumentNullException>("fileInfo", () =>
-                CreateFileWithSecurity(info, FileMode.CreateNew, FileSystemRights.WriteData, FileShare.Delete, DefaultBufferSize, FileOptions.None, security));
-        }
-
-        [Fact]
-        public void FileInfo_Create_NullFileSecurity()
-        {
-            var info = new FileInfo("path");
-
-            Assert.Throws<ArgumentNullException>("fileSecurity", () =>
-                CreateFileWithSecurity(info, FileMode.CreateNew, FileSystemRights.WriteData, FileShare.Delete, DefaultBufferSize, FileOptions.None, null));
+                info.Create(FileMode.CreateNew, FileSystemRights.FullControl, FileShare.None, DefaultBufferSize, FileOptions.None, security));
         }
 
         [Fact]
-        public void FileInfo_Create_NotFound()
+        public void FileInfo_Create_DirectoryNotFound()
         {
             using var tempRootDir = new TempAclDirectory();
             string path = Path.Combine(tempRootDir.Path, Guid.NewGuid().ToString(), "file.txt");
-            var fileInfo = new FileInfo(path);
+            var info = new FileInfo(path);
             var security = new FileSecurity();
-
             Assert.Throws<DirectoryNotFoundException>(() =>
-                CreateFileWithSecurity(fileInfo, FileMode.CreateNew, FileSystemRights.WriteData, FileShare.Delete, DefaultBufferSize, FileOptions.None, security));
+                info.Create(FileMode.CreateNew, FileSystemRights.FullControl, FileShare.None, DefaultBufferSize, FileOptions.None, security));
         }
 
         [Theory]
         [InlineData((FileMode)int.MinValue)]
         [InlineData((FileMode)0)]
         [InlineData((FileMode)int.MaxValue)]
-        public void FileInfo_Create_FileSecurity_InvalidFileMode(FileMode invalidMode)
-        {
-            var security = new FileSecurity();
-            var info = new FileInfo("path");
-
-            Assert.Throws<ArgumentOutOfRangeException>("mode", () =>
-                CreateFileWithSecurity(info, invalidMode, FileSystemRights.WriteData, FileShare.Delete, DefaultBufferSize, FileOptions.None, security));
-        }
+        public void FileInfo_Create_FileSecurity_OutOfRange_FileMode(FileMode invalidMode) =>
+            FileInfo_Create_FileSecurity_ArgumentOutOfRangeException("mode", mode: invalidMode);
 
         [Theory]
         [InlineData((FileShare)(-1))]
         [InlineData((FileShare)int.MaxValue)]
-        public void FileInfo_Create_FileSecurity_InvalidFileShare(FileShare invalidFileShare)
-        {
-            var security = new FileSecurity();
-            var info = new FileInfo("path");
-
-            Assert.Throws<ArgumentOutOfRangeException>("share", () =>
-                CreateFileWithSecurity(info, FileMode.CreateNew, FileSystemRights.WriteData, invalidFileShare, DefaultBufferSize, FileOptions.None, security));
-        }
+        public void FileInfo_Create_FileSecurity_OutOfRange_FileShare(FileShare invalidFileShare) =>
+            FileInfo_Create_FileSecurity_ArgumentOutOfRangeException("share", share: invalidFileShare);
 
         [Theory]
         [InlineData(int.MinValue)]
         [InlineData(0)]
-        public void FileInfo_Create_FileSecurity_InvalidBufferSize(int invalidBufferSize)
-        {
-            var security = new FileSecurity();
-            var info = new FileInfo("path");
+        public void FileInfo_Create_FileSecurity_OutOfRange_BufferSize(int invalidBufferSize) =>
+            FileInfo_Create_FileSecurity_ArgumentOutOfRangeException("bufferSize", bufferSize: invalidBufferSize);
+
+        public static IEnumerable<object[]> WriteModes_ReadRights_ForbiddenCombo_Data() =>
+            from mode in s_writableModes
+            from rights in s_readableRights
+            where
+                // These combinations are allowed, exclude them
+                !(rights == FileSystemRights.CreateFiles &&
+                  (mode == FileMode.Append || mode == FileMode.Create || mode == FileMode.CreateNew))
+            select new object[] { mode, rights };
+
+        // Do not combine writing modes with exclusively read rights
+        [Theory]
+        [MemberData(nameof(WriteModes_ReadRights_ForbiddenCombo_Data))]
+        public void FileInfo_Create_FileSecurity_WriteModes_ReadRights_ForbiddenCombo(FileMode mode, FileSystemRights rights) =>
+            FileInfo_Create_FileSecurity_ArgumentException(mode, rights);
 
-            Assert.Throws<ArgumentOutOfRangeException>("bufferSize", () =>
-                CreateFileWithSecurity(info, FileMode.CreateNew, FileSystemRights.WriteData, FileShare.Delete, invalidBufferSize, FileOptions.None, security));
-        }
+        public static IEnumerable<object[]> OpenOrCreateMode_ReadRights_AllowedCombo_Data() =>
+            from rights in s_readableRights
+            select new object[] { rights };
 
+        // OpenOrCreate allows using exclusively read rights
         [Theory]
-        [InlineData(FileMode.Truncate,  FileSystemRights.Read)]
-        [InlineData(FileMode.Truncate,  FileSystemRights.ReadData)]
-        [InlineData(FileMode.CreateNew, FileSystemRights.Read)]
-        [InlineData(FileMode.CreateNew, FileSystemRights.ReadData)]
-        [InlineData(FileMode.Create,    FileSystemRights.Read)]
-        [InlineData(FileMode.Create,    FileSystemRights.ReadData)]
-        [InlineData(FileMode.Append,    FileSystemRights.Read)]
-        [InlineData(FileMode.Append,    FileSystemRights.ReadData)]
-        public void FileInfo_Create_FileSecurity_ForbiddenCombo_FileModeFileSystemSecurity(FileMode mode, FileSystemRights rights)
-        {
-            var security = new FileSecurity();
-            var info = new FileInfo("path");
+        [MemberData(nameof(OpenOrCreateMode_ReadRights_AllowedCombo_Data))]
+        public void FileInfo_Create_FileSecurity_OpenOrCreateMode_ReadRights_AllowedCombo(FileSystemRights rights) =>
+            FileInfo_Create_FileSecurity_Successful(FileMode.OpenOrCreate, rights);
 
-            Assert.Throws<ArgumentException>(() =>
-                CreateFileWithSecurity(info, mode, rights, FileShare.Delete, DefaultBufferSize, FileOptions.None, security));
-        }
+        // Append, Create and CreateNew allow using CreateFiles rights
+        // These combinations were excluded from WriteModes_ReadRights_ForbiddenCombo_Data
+        [Theory]
+        [InlineData(FileMode.Append)]
+        [InlineData(FileMode.Create)]
+        [InlineData(FileMode.CreateNew)]
+        public void FileInfo_Create_FileSecurity_WriteModes_CreateFilesRights_AllowedCombo(FileMode mode) =>
+            FileInfo_Create_FileSecurity_Successful(mode, FileSystemRights.CreateFiles);
+
+        public static IEnumerable<object[]> AppendMode_UnexpectedReadRights_Data() =>
+            from writeRights in s_writableRights
+            from readRights in new[] {
+                FileSystemRights.ExecuteFile,
+                FileSystemRights.ReadAttributes, FileSystemRights.ReadData, FileSystemRights.ReadExtendedAttributes, FileSystemRights.ReadPermissions,
+                FileSystemRights.Read, // Contains ReadAttributes, ReadData, ReadExtendedAttributes, ReadPermissions
+                FileSystemRights.ReadAndExecute, // Contains Read and ExecuteFile
+            }
+            select new object[] { writeRights | readRights };
+
+        // Append is allowed if at least one write permission is provided
+        // But append is disallowed if any read rights are provided
+        [Theory]
+        [MemberData(nameof(AppendMode_UnexpectedReadRights_Data))]
+        public void FileInfo_Create_FileSecurity_AppendMode_UnexpectedReadRights(FileSystemRights rights) =>
+            FileInfo_Create_FileSecurity_ArgumentException(FileMode.Append, rights);
+
+        public static IEnumerable<object[]> AppendMode_OnlyWriteRights_Data() =>
+            from writeRights in s_writableRights
+            select new object[] { writeRights };
+
+        // Append succeeds if only write permissions were provided (no read permissions)
+        [Theory]
+        [MemberData(nameof(AppendMode_OnlyWriteRights_Data))]
+        public void FileInfo_Create_FileSecurity_AppendMode_OnlyWriteRights(FileSystemRights rights) =>
+            FileInfo_Create_FileSecurity_Successful(FileMode.Append, rights);
+
+        public static IEnumerable<object[]> WritableRights_Data() =>
+            from rights in s_writableRights
+            select new object[] { rights };
+
+        // Cannot truncate unless all write rights are provided
+        [Theory]
+        [MemberData(nameof(WritableRights_Data))]
+        public void FileInfo_Create_FileSecurity_TruncateMode_IncompleteWriteRights(FileSystemRights rights) =>
+            FileInfo_Create_FileSecurity_ArgumentException(FileMode.Truncate, rights);
 
         [Fact]
-        public void FileInfo_Create_DefaultFileSecurity()
+        public void FileInfo_Create_FileSecurity_TruncateMode_AllWriteRights_Throws()
         {
+            // Truncate, with all write rights, throws with different messages in each framework:
+            // - In .NET Framework, throws "Could not find file"
+            // - In .NET, throws IOException: "The parameter is incorrect"
+
             var security = new FileSecurity();
-            Verify_FileSecurity_CreateFile(security);
+            var info = new FileInfo(Guid.NewGuid().ToString());
+            Assert.Throws<IOException>(() => info.Create(FileMode.Truncate, FileSystemRights.Write | FileSystemRights.ReadData, FileShare.None, DefaultBufferSize, FileOptions.None, security));
         }
 
-        private void CreateFileWithSecurity(FileInfo info, FileMode mode, FileSystemRights rights, FileShare share, int bufferSize, FileOptions options, FileSecurity security)
-        {
-            if (PlatformDetection.IsNetFramework)
-            {
-                FileSystemAclExtensions.Create(info, mode, rights, share, bufferSize, options, security);
-            }
-            else
-            {
-                info.Create(mode, rights, share, bufferSize, options, security);
-            }
-        }
+        public static IEnumerable<object[]> WriteRights_AllArguments_Data() =>
+            from mode in s_writableModes
+            from rights in s_writableRights
+            from share in Enum.GetValues<FileShare>()
+            from options in Enum.GetValues<FileOptions>()
+            where !(rights == FileSystemRights.CreateFiles &&
+                    (mode == FileMode.Append || mode == FileMode.Create || mode == FileMode.CreateNew)) &&
+                  !(mode == FileMode.Truncate && rights != FileSystemRights.Write) &&
+                  options != FileOptions.Encrypted // Using FileOptions.Encrypted throws UnauthorizedAccessException when attempting to read the created file
+            select new object[] { mode, rights, share, options };
 
         [Theory]
-        // Must have at least one Read, otherwise the TempAclDirectory will fail to delete that item on dispose
-        [MemberData(nameof(RightsToAllow))]
-        public void FileInfo_Create_AllowSpecific_AccessRules(FileSystemRights rights)
-        {
-            using var tempRootDir = new TempAclDirectory();
-            string path = Path.Combine(tempRootDir.Path, "file.txt");
-            var fileInfo = new FileInfo(path);
+        [MemberData(nameof(WriteRights_AllArguments_Data))]
+        public void FileInfo_WriteRights_WithSecurity_Null(FileMode mode, FileSystemRights rights, FileShare share, FileOptions options) =>
+            Verify_FileSecurity_CreateFile(mode, rights, share, DefaultBufferSize, options, expectedSecurity: null); // Null security
 
-            FileSecurity expectedSecurity = GetFileSecurity(rights);
+        [Theory]
+        [MemberData(nameof(WriteRights_AllArguments_Data))]
+        public void FileInfo_WriteRights_WithSecurity_Default(FileMode mode, FileSystemRights rights, FileShare share, FileOptions options) =>
+            Verify_FileSecurity_CreateFile(mode, rights, share, DefaultBufferSize, options, new FileSecurity()); // Default security
 
-            using FileStream stream = fileInfo.Create(
-                FileMode.Create,
-                FileSystemRights.FullControl,
-                FileShare.ReadWrite | FileShare.Delete,
-                DefaultBufferSize,
-                FileOptions.None,
-                expectedSecurity);
+        [Theory]
+        [MemberData(nameof(WriteRights_AllArguments_Data))]
+        public void FileInfo_WriteRights_WithSecurity_Custom(FileMode mode, FileSystemRights rights, FileShare share, FileOptions options) =>
+            Verify_FileSecurity_CreateFile(mode, rights, share, DefaultBufferSize, options, GetFileSecurity(rights)); // Custom security (AccessRule Allow)
+
+        public static IEnumerable<object[]> ReadRights_AllArguments_Data() =>
+            from mode in new[] { FileMode.Create, FileMode.CreateNew, FileMode.OpenOrCreate }
+            from rights in s_readableRights
+            from share in Enum.GetValues<FileShare>()
+            from options in Enum.GetValues<FileOptions>()
+            where options != FileOptions.Encrypted // Using FileOptions.Encrypted throws UnauthorizedAccessException when attempting to read the created file
+            select new object[] { mode, rights, share, options };
 
-            Assert.True(fileInfo.Exists);
-            tempRootDir.CreatedSubfiles.Add(fileInfo);
+        [Theory]
+        [MemberData(nameof(ReadRights_AllArguments_Data))]
+        public void FileInfo_ReadRights_WithSecurity_Null(FileMode mode, FileSystemRights rights, FileShare share, FileOptions options) =>
+            // Writable FileModes require at least one write right
+            Verify_FileSecurity_CreateFile(mode, rights | FileSystemRights.WriteData, share, DefaultBufferSize, options, expectedSecurity: null); // Null security
 
-            var actualInfo = new FileInfo(fileInfo.FullName);
-            FileSecurity actualSecurity = actualInfo.GetAccessControl(AccessControlSections.Access);
-            VerifyAccessSecurity(expectedSecurity, actualSecurity);
-        }
+        [Theory]
+        [MemberData(nameof(ReadRights_AllArguments_Data))]
+        public void FileInfo_ReadRights_WithSecurity_Default(FileMode mode, FileSystemRights rights, FileShare share, FileOptions options) =>
+            // Writable FileModes require at least one write right
+            Verify_FileSecurity_CreateFile(mode, rights | FileSystemRights.WriteData, share, DefaultBufferSize, options, new FileSecurity()); // Default security
 
+        [Theory]
+        [MemberData(nameof(ReadRights_AllArguments_Data))]
+        public void FileInfo_ReadRights_WithSecurity_Custom(FileMode mode, FileSystemRights rights, FileShare share, FileOptions options) =>
+            // Writable FileModes require at least one write right
+            Verify_FileSecurity_CreateFile(mode, rights | FileSystemRights.WriteData, share, DefaultBufferSize, options, GetFileSecurity(rights)); // Custom security (AccessRule Allow)
 
         [Theory]
         [MemberData(nameof(RightsToDeny))]
-        public void FileInfo_Create_DenySpecific_AccessRules(FileSystemRights rightsToDeny)
+        public void FileInfo_Create_FileSecurity_DenyAccessRule(FileSystemRights rightsToDeny)
         {
             var expectedSecurity = new FileSecurity();
 
             var identity = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
-            var allowAccessRule = new FileSystemAccessRule(identity, FileSystemRights.Read, AccessControlType.Allow);
-            expectedSecurity.AddAccessRule(allowAccessRule);
 
+            // Add write deny rule
             var denyAccessRule = new FileSystemAccessRule(identity, rightsToDeny, AccessControlType.Deny);
             expectedSecurity.AddAccessRule(denyAccessRule);
 
             using var tempRootDir = new TempAclDirectory();
 
-            string path = Path.Combine(tempRootDir.Path, "file.txt");
+            string path = Path.Combine(tempRootDir.Path, Guid.NewGuid().ToString());
             var fileInfo = new FileInfo(path);
 
             using FileStream stream = fileInfo.Create(
-                FileMode.Create,
-                FileSystemRights.FullControl,
-                FileShare.ReadWrite | FileShare.Delete,
+                FileMode.CreateNew,
+                FileSystemRights.Write, // Create expects at least one write right
+                FileShare.None,
                 DefaultBufferSize,
                 FileOptions.None,
                 expectedSecurity);
@@ -451,7 +491,6 @@ public void FileInfo_Create_DenySpecific_AccessRules(FileSystemRights rightsToDe
         #region DirectorySecurity CreateDirectory
 
         [Fact]
-        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
         public void DirectorySecurity_CreateDirectory_NullSecurity()
         {
             DirectorySecurity security = null;
@@ -474,7 +513,7 @@ public void DirectorySecurity_CreateDirectory_InvalidPath()
         public void DirectorySecurity_CreateDirectory_DirectoryAlreadyExists()
         {
             using var tempRootDir = new TempAclDirectory();
-            string path = Path.Combine(tempRootDir.Path, "createMe");
+            string path = Path.Combine(tempRootDir.Path, Guid.NewGuid().ToString());
 
             DirectorySecurity expectedSecurity = GetDirectorySecurity(FileSystemRights.FullControl);
             DirectoryInfo dirInfo = expectedSecurity.CreateDirectory(path);
@@ -496,84 +535,137 @@ public void DirectorySecurity_CreateDirectory_DirectoryAlreadyExists()
 
         #region Helper methods
 
-        public static IEnumerable<object[]> RightsToDeny()
-        {
-            yield return new object[] { FileSystemRights.AppendData };
-            yield return new object[] { FileSystemRights.ChangePermissions };
-            // yield return new object[] { FileSystemRights.CreateDirectories }; // CreateDirectories == AppendData
-            yield return new object[] { FileSystemRights.CreateFiles };
-            yield return new object[] { FileSystemRights.Delete };
-            yield return new object[] { FileSystemRights.DeleteSubdirectoriesAndFiles };
-            yield return new object[] { FileSystemRights.ExecuteFile };
-            // yield return new object[] { FileSystemRights.FullControl }; // Contains ReadData, should not deny that
-            // yield return new object[] { FileSystemRights.ListDirectory }; ListDirectory == ReadData
-            // yield return new object[] { FileSystemRights.Modify }; // Contains ReadData, should not deny that
-            // yield return new object[] { FileSystemRights.Read }; // Contains ReadData, should not deny that
-            // yield return new object[] { FileSystemRights.ReadAndExecute }; // Contains ReadData, should not deny that
-            yield return new object[] { FileSystemRights.ReadAttributes };
-            // yield return new object[] { FileSystemRights.ReadData }; // Minimum right required to delete a file or directory
-            yield return new object[] { FileSystemRights.ReadExtendedAttributes };
-            yield return new object[] { FileSystemRights.ReadPermissions };
-            // yield return new object[] { FileSystemRights.Synchronize }; // CreateFile always requires Synchronize access
-            yield return new object[] { FileSystemRights.TakeOwnership };
-            //yield return new object[] { FileSystemRights.Traverse }; // Traverse == ExecuteFile
-            yield return new object[] { FileSystemRights.Write };
-            yield return new object[] { FileSystemRights.WriteAttributes };
-            // yield return new object[] { FileSystemRights.WriteData }; // WriteData == CreateFiles
-            yield return new object[] { FileSystemRights.WriteExtendedAttributes };
-        }
-
-        public static IEnumerable<object[]> RightsToAllow()
-        {
-            yield return new object[] { FileSystemRights.AppendData };
-            yield return new object[] { FileSystemRights.ChangePermissions };
-            // yield return new object[] { FileSystemRights.CreateDirectories }; // CreateDirectories == AppendData
-            yield return new object[] { FileSystemRights.CreateFiles };
-            yield return new object[] { FileSystemRights.Delete };
-            yield return new object[] { FileSystemRights.DeleteSubdirectoriesAndFiles };
-            yield return new object[] { FileSystemRights.ExecuteFile };
-            yield return new object[] { FileSystemRights.FullControl };
-            // yield return new object[] { FileSystemRights.ListDirectory }; ListDirectory == ReadData
-            yield return new object[] { FileSystemRights.Modify };
-            yield return new object[] { FileSystemRights.Read };
-            yield return new object[] { FileSystemRights.ReadAndExecute };
-            yield return new object[] { FileSystemRights.ReadAttributes };
-            // yield return new object[] { FileSystemRights.ReadData }; // Minimum right required to delete a file or directory
-            yield return new object[] { FileSystemRights.ReadExtendedAttributes };
-            yield return new object[] { FileSystemRights.ReadPermissions };
-            yield return new object[] { FileSystemRights.Synchronize };
-            yield return new object[] { FileSystemRights.TakeOwnership };
-            // yield return new object[] { FileSystemRights.Traverse }; // Traverse == ExecuteFile
-            yield return new object[] { FileSystemRights.Write };
-            yield return new object[] { FileSystemRights.WriteAttributes };
-            // yield return new object[] { FileSystemRights.WriteData }; // WriteData == CreateFiles
-            yield return new object[] { FileSystemRights.WriteExtendedAttributes };
-        }
-
-        private void Verify_FileSecurity_CreateFile(FileSecurity expectedSecurity)
-        {
-            Verify_FileSecurity_CreateFile(FileMode.Create, FileSystemRights.WriteData, FileShare.Read, DefaultBufferSize, FileOptions.None, expectedSecurity);
+        public static IEnumerable<object[]> RightsToDeny() =>
+            from rights in new[] {
+                FileSystemRights.AppendData, // Same as CreateDirectories
+                FileSystemRights.ChangePermissions,
+                FileSystemRights.Delete,
+                FileSystemRights.DeleteSubdirectoriesAndFiles,
+                FileSystemRights.ExecuteFile, // Same as Traverse
+                FileSystemRights.ReadAttributes,
+                FileSystemRights.ReadExtendedAttributes,
+                FileSystemRights.ReadPermissions,
+                FileSystemRights.TakeOwnership,
+                FileSystemRights.Write, // Contains AppendData, WriteData, WriteAttributes, WriteExtendedAttributes
+                FileSystemRights.WriteAttributes,
+                FileSystemRights.WriteData, // Same as CreateFiles
+                FileSystemRights.WriteExtendedAttributes,
+                // Rights that should not be denied:
+                // - Synchronize: CreateFile always requires Synchronize access
+                // - ReadData: Minimum right required to delete a file or directory
+                // - ListDirectory: Equivalent to ReadData
+                // - Modify: Contains ReadData
+                // - Read: Contains ReadData
+                // - ReadAndExecute: Contains ReadData
+                // - FullControl: Contains ReadData and Synchronize
+            }
+            select new object[] { rights };
+
+        public static IEnumerable<object[]> RightsToAllow() =>
+            from rights in new[] {
+                FileSystemRights.AppendData, // Same as CreateDirectories
+                FileSystemRights.ChangePermissions,
+                FileSystemRights.Delete,
+                FileSystemRights.DeleteSubdirectoriesAndFiles,
+                FileSystemRights.ExecuteFile, // Same as Traverse
+                FileSystemRights.Modify, // Contains Read, Write and ReadAndExecute
+                FileSystemRights.Read, // Contains ReadData, ReadPermissions, ReadAttributes, ReadExtendedAttributes
+                FileSystemRights.ReadAndExecute, // Contains Read and ExecuteFile
+                FileSystemRights.ReadAttributes,
+                FileSystemRights.ReadData, // Minimum right required to delete a file or directory. Equivalent to ListDirectory
+                FileSystemRights.ReadExtendedAttributes,
+                FileSystemRights.ReadPermissions,
+                FileSystemRights.Synchronize, // CreateFile always requires Synchronize access
+                FileSystemRights.TakeOwnership,
+                FileSystemRights.Write, // Contains AppendData, WriteData, WriteAttributes, WriteExtendedAttributes
+                FileSystemRights.WriteAttributes,
+                FileSystemRights.WriteData, // Same as CreateFiles
+                FileSystemRights.WriteExtendedAttributes,
+                FileSystemRights.FullControl, // Contains Modify, DeleteSubdirectoriesAndFiles, Delete, ChangePermissions, TakeOwnership, Synchronize
+            }
+            select new object[] { rights };
+
+        private static readonly FileMode[] s_writableModes = new[]
+        {
+            FileMode.Append,
+            FileMode.Create,
+            FileMode.CreateNew,
+            FileMode.Truncate
+            // Excludes OpenOrCreate because it has a different behavior compared to Create/CreateNew
+        };
+
+        private static readonly FileSystemRights[] s_readableRights = new[]
+        {
+            // Excludes combined rights
+            FileSystemRights.ExecuteFile,
+            FileSystemRights.ReadAttributes,
+            FileSystemRights.ReadData,
+            FileSystemRights.ReadExtendedAttributes,
+            FileSystemRights.ReadPermissions
+        };
+
+        private static readonly FileSystemRights[] s_writableRights = new[]
+        {
+            // Excludes combined rights
+            FileSystemRights.AppendData, // Same as CreateDirectories
+            FileSystemRights.WriteAttributes,
+            FileSystemRights.WriteData,
+            FileSystemRights.WriteExtendedAttributes
+        };
+
+        private void FileInfo_Create_FileSecurity_ArgumentOutOfRangeException(string paramName, FileMode mode = FileMode.CreateNew, FileShare share = FileShare.None, int bufferSize = DefaultBufferSize)
+        {
+            var security = new FileSecurity();
+            var info = new FileInfo(Guid.NewGuid().ToString());
+            Assert.Throws<ArgumentOutOfRangeException>(paramName, () =>
+                info.Create(mode, FileSystemRights.FullControl, share, bufferSize, FileOptions.None, security));
+        }
+
+        private void FileInfo_Create_FileSecurity_ArgumentException(FileMode mode, FileSystemRights rights)
+        {
+            var security = new FileSecurity();
+            var info = new FileInfo(Guid.NewGuid().ToString());
+            Assert.Throws<ArgumentException>(() =>
+                info.Create(mode, rights, FileShare.None, DefaultBufferSize, FileOptions.None, security));
+        }
+
+        private void FileInfo_Create_FileSecurity_Successful(FileMode mode, FileSystemRights rights)
+        {
+            var security = new FileSecurity();
+            var info = new FileInfo(Guid.NewGuid().ToString());
+            info.Create(mode, rights, FileShare.None, DefaultBufferSize, FileOptions.None, security).Dispose();
         }
 
         private void Verify_FileSecurity_CreateFile(FileMode mode, FileSystemRights rights, FileShare share, int bufferSize, FileOptions options, FileSecurity expectedSecurity)
         {
             using var tempRootDir = new TempAclDirectory();
-            string path = Path.Combine(tempRootDir.Path, "file.txt");
+            string path = Path.Combine(tempRootDir.Path, Guid.NewGuid().ToString());
             var fileInfo = new FileInfo(path);
 
-            fileInfo.Create(mode, rights, share, bufferSize, options, expectedSecurity).Dispose();
-            Assert.True(fileInfo.Exists);
-            tempRootDir.CreatedSubfiles.Add(fileInfo);
+            using (FileStream fs = fileInfo.Create(mode, rights, share, bufferSize, options, expectedSecurity))
+            {
+                Assert.True(fileInfo.Exists);
+                tempRootDir.CreatedSubfiles.Add(fileInfo);
 
-            var actualFileInfo = new FileInfo(path);
-            FileSecurity actualSecurity = actualFileInfo.GetAccessControl(AccessControlSections.Access);
-            VerifyAccessSecurity(expectedSecurity, actualSecurity);
+                var actualFileInfo = new FileInfo(path);
+                FileSecurity actualSecurity = actualFileInfo.GetAccessControl();
+
+                if (expectedSecurity != null)
+                {
+                    VerifyAccessSecurity(expectedSecurity, actualSecurity);
+                }
+                else
+                {
+                    int count = actualSecurity.GetAccessRules(includeExplicit: true, includeInherited: false, typeof(SecurityIdentifier)).Count;
+                    Assert.Equal(0, count);
+                }
+            }
         }
 
         private void Verify_DirectorySecurity_CreateDirectory(DirectorySecurity expectedSecurity)
         {
             using var tempRootDir = new TempAclDirectory();
-            string path = Path.Combine(tempRootDir.Path, "createMe");
+            string path = Path.Combine(tempRootDir.Path, Guid.NewGuid().ToString());
             DirectoryInfo dirInfo = expectedSecurity.CreateDirectory(path);
             Assert.True(dirInfo.Exists);
             tempRootDir.CreatedSubdirectories.Add(dirInfo);

From a9c96461388aad0c47f8d49435893203ee60224a Mon Sep 17 00:00:00 2001
From: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date: Mon, 24 Jan 2022 11:55:05 +0300
Subject: [PATCH 022/161] Tune FP CSEs live across a call better (#63903)

The problem was that the comparison of a weighted refcount,
which usually has the order of hundreds or tens, with a small
digit like "4" was too weak and missed some cases where we
were still trying to CSE cheaps floats across calls and ending
up with lots of stack shuffling.

Fix this by using different tuning parameters, namely the costs
estimated for the uses and defs (increase them to account for
the spills and reloads).
---
 src/coreclr/jit/optcse.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/coreclr/jit/optcse.cpp b/src/coreclr/jit/optcse.cpp
index 805e5b7d2eb3f5..108fde7e984976 100644
--- a/src/coreclr/jit/optcse.cpp
+++ b/src/coreclr/jit/optcse.cpp
@@ -2599,17 +2599,18 @@ class CSE_Heuristic
             cse_use_cost *= slotCount;
         }
 
-        // If this CSE is live across a call then we may need to spill an additional caller save register
+        // If this CSE is live across a call then we may have additional costs
         //
         if (candidate->LiveAcrossCall())
         {
-            if (candidate->Expr()->IsCnsFltOrDbl() && (CNT_CALLEE_SAVED_FLOAT == 0) &&
-                (candidate->CseDsc()->csdUseWtCnt <= 4))
+            // If we have a floating-point CSE that is both live across a call and there
+            // are no callee-saved FP registers available, the RA will have to spill at
+            // the def site and reload at the (first) use site, if the variable is a register
+            // candidate. Account for that.
+            if (varTypeIsFloating(candidate->Expr()) && (CNT_CALLEE_SAVED_FLOAT == 0) && !candidate->IsConservative())
             {
-                // Floating point constants are expected to be contained, so unless there are more than 4 uses
-                // we better not to CSE them, especially on platforms without callee-saved registers
-                // for values living across calls
-                return false;
+                cse_def_cost += 1;
+                cse_use_cost += 1;
             }
 
             // If we don't have a lot of variables to enregister or we have a floating point type

From bde7069e7e1a2eb05fe9cc838b4de0f982a72544 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Mon, 24 Jan 2022 10:08:44 +0100
Subject: [PATCH 023/161] [main] Update dependencies from dotnet/arcade
 dotnet/icu dotnet/xharness dotnet/emsdk (#64098)

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
---
 .config/dotnet-tools.json                     |   2 +-
 eng/Version.Details.xml                       |  96 +++++++-------
 eng/Versions.props                            |  40 +++---
 eng/common/internal/NuGet.config              |   7 +
 eng/common/templates/job/execute-sdl.yml      |  13 +-
 eng/common/templates/job/onelocbuild.yml      |   3 +-
 eng/common/templates/jobs/jobs.yml            |   4 +-
 .../templates/post-build/common-variables.yml |  69 ----------
 .../templates/post-build/post-build.yml       |  74 +++++------
 .../post-build/setup-maestro-vars.yml         | 123 ++++++++----------
 global.json                                   |   8 +-
 11 files changed, 175 insertions(+), 264 deletions(-)
 create mode 100644 eng/common/internal/NuGet.config

diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
index 0e5219042b700d..26dc5ae6a75f47 100644
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -15,7 +15,7 @@
       ]
     },
     "microsoft.dotnet.xharness.cli": {
-      "version": "1.0.0-prerelease.22067.1",
+      "version": "1.0.0-prerelease.22071.1",
       "commands": [
         "xharness"
       ]
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index af284815b19ecb..ee709f74031a46 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -1,16 +1,16 @@
 <Dependencies>
   <ProductDependencies>
-    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="7.0.0-alpha.1.22067.1">
+    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="7.0.0-preview.2.22071.2">
       <Uri>https://github.com/dotnet/icu</Uri>
-      <Sha>4170ccfbbcada3e22aa4428a84524fabef006e38</Sha>
+      <Sha>8a4a45cc99e7d6e5244c16f581171633091b96b3</Sha>
     </Dependency>
     <Dependency Name="System.Net.MsQuic.Transport" Version="7.0.0-alpha.1.21529.3">
       <Uri>https://github.com/dotnet/msquic</Uri>
       <Sha>a7213b4676c1803bb251771291a525482d42e511</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NET.Workload.Emscripten.Manifest-7.0.100" Version="7.0.0-alpha.1.21601.1">
+    <Dependency Name="Microsoft.NET.Workload.Emscripten.Manifest-7.0.100" Version="7.0.0-alpha.2.22071.3">
       <Uri>https://github.com/dotnet/emsdk</Uri>
-      <Sha>4eb953d7051890da4f36167125c6b41e06d7f56d</Sha>
+      <Sha>aaa56a6622c4991cf65d553250af3c0ade1320bc</Sha>
     </Dependency>
     <Dependency Name="System.ServiceModel.Primitives" Version="4.9.0-rc2.21473.1">
       <Uri>https://github.com/dotnet/wcf</Uri>
@@ -50,77 +50,77 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenAPI" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.GenAPI" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenFacades" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.GenFacades" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Templating" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Templating" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Workloads" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Workloads" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NET.Test.Sdk" Version="16.9.0-preview-20201201-01">
       <Uri>https://github.com/microsoft/vstest</Uri>
@@ -238,21 +238,21 @@
       <Uri>https://github.com/dotnet/linker</Uri>
       <Sha>e485816b48273d03bd6266a64dad9bea97f861d5</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Common" Version="1.0.0-prerelease.22067.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Common" Version="1.0.0-prerelease.22071.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>3060cda4543b80824a9238bcd176bb1a5af72044</Sha>
+      <Sha>bd2a12f9cc6c93c249f987b42c1c761550369674</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.22067.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.22071.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>3060cda4543b80824a9238bcd176bb1a5af72044</Sha>
+      <Sha>bd2a12f9cc6c93c249f987b42c1c761550369674</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.22067.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.22071.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>3060cda4543b80824a9238bcd176bb1a5af72044</Sha>
+      <Sha>bd2a12f9cc6c93c249f987b42c1c761550369674</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="7.0.0-beta.22068.3">
+    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="7.0.0-beta.22071.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>9ffc76ac9f5799de9b28ee59f9bfbe0f8844d0d7</Sha>
+      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
     </Dependency>
     <Dependency Name="optimization.windows_nt-x64.MIBC.Runtime" Version="1.0.0-prerelease.21577.2">
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 04f7adea4cff9d..85e7bdd4cdc822 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -54,21 +54,21 @@
     <!-- SDK dependencies -->
     <MicrosoftDotNetCompatibilityVersion>2.0.0-alpha.1.21525.11</MicrosoftDotNetCompatibilityVersion>
     <!-- Arcade dependencies -->
-    <MicrosoftDotNetApiCompatVersion>7.0.0-beta.22068.3</MicrosoftDotNetApiCompatVersion>
-    <MicrosoftDotNetBuildTasksFeedVersion>7.0.0-beta.22068.3</MicrosoftDotNetBuildTasksFeedVersion>
-    <MicrosoftDotNetCodeAnalysisVersion>7.0.0-beta.22068.3</MicrosoftDotNetCodeAnalysisVersion>
-    <MicrosoftDotNetGenAPIVersion>7.0.0-beta.22068.3</MicrosoftDotNetGenAPIVersion>
-    <MicrosoftDotNetGenFacadesVersion>7.0.0-beta.22068.3</MicrosoftDotNetGenFacadesVersion>
-    <MicrosoftDotNetXUnitExtensionsVersion>7.0.0-beta.22068.3</MicrosoftDotNetXUnitExtensionsVersion>
-    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.22068.3</MicrosoftDotNetXUnitConsoleRunnerVersion>
-    <MicrosoftDotNetBuildTasksArchivesVersion>7.0.0-beta.22068.3</MicrosoftDotNetBuildTasksArchivesVersion>
-    <MicrosoftDotNetBuildTasksInstallersVersion>7.0.0-beta.22068.3</MicrosoftDotNetBuildTasksInstallersVersion>
-    <MicrosoftDotNetBuildTasksPackagingVersion>7.0.0-beta.22068.3</MicrosoftDotNetBuildTasksPackagingVersion>
-    <MicrosoftDotNetBuildTasksTemplatingVersion>7.0.0-beta.22068.3</MicrosoftDotNetBuildTasksTemplatingVersion>
-    <MicrosoftDotNetBuildTasksWorkloadsPackageVersion>7.0.0-beta.22068.3</MicrosoftDotNetBuildTasksWorkloadsPackageVersion>
-    <MicrosoftDotNetRemoteExecutorVersion>7.0.0-beta.22068.3</MicrosoftDotNetRemoteExecutorVersion>
-    <MicrosoftDotNetVersionToolsTasksVersion>7.0.0-beta.22068.3</MicrosoftDotNetVersionToolsTasksVersion>
-    <MicrosoftDotNetPackageTestingVersion>7.0.0-beta.22068.3</MicrosoftDotNetPackageTestingVersion>
+    <MicrosoftDotNetApiCompatVersion>7.0.0-beta.22071.6</MicrosoftDotNetApiCompatVersion>
+    <MicrosoftDotNetBuildTasksFeedVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksFeedVersion>
+    <MicrosoftDotNetCodeAnalysisVersion>7.0.0-beta.22071.6</MicrosoftDotNetCodeAnalysisVersion>
+    <MicrosoftDotNetGenAPIVersion>7.0.0-beta.22071.6</MicrosoftDotNetGenAPIVersion>
+    <MicrosoftDotNetGenFacadesVersion>7.0.0-beta.22071.6</MicrosoftDotNetGenFacadesVersion>
+    <MicrosoftDotNetXUnitExtensionsVersion>7.0.0-beta.22071.6</MicrosoftDotNetXUnitExtensionsVersion>
+    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.22071.6</MicrosoftDotNetXUnitConsoleRunnerVersion>
+    <MicrosoftDotNetBuildTasksArchivesVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksArchivesVersion>
+    <MicrosoftDotNetBuildTasksInstallersVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksInstallersVersion>
+    <MicrosoftDotNetBuildTasksPackagingVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksPackagingVersion>
+    <MicrosoftDotNetBuildTasksTemplatingVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksTemplatingVersion>
+    <MicrosoftDotNetBuildTasksWorkloadsPackageVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksWorkloadsPackageVersion>
+    <MicrosoftDotNetRemoteExecutorVersion>7.0.0-beta.22071.6</MicrosoftDotNetRemoteExecutorVersion>
+    <MicrosoftDotNetVersionToolsTasksVersion>7.0.0-beta.22071.6</MicrosoftDotNetVersionToolsTasksVersion>
+    <MicrosoftDotNetPackageTestingVersion>7.0.0-beta.22071.6</MicrosoftDotNetPackageTestingVersion>
     <!-- NuGet dependencies -->
     <NuGetBuildTasksPackVersion>6.0.0-preview.1.102</NuGetBuildTasksPackVersion>
     <!-- Installer dependencies -->
@@ -160,9 +160,9 @@
     <!-- Testing -->
     <MicrosoftNETCoreCoreDisToolsVersion>1.0.1-prerelease-00006</MicrosoftNETCoreCoreDisToolsVersion>
     <MicrosoftNETTestSdkVersion>16.9.0-preview-20201201-01</MicrosoftNETTestSdkVersion>
-    <MicrosoftDotNetXHarnessTestRunnersCommonVersion>1.0.0-prerelease.22067.1</MicrosoftDotNetXHarnessTestRunnersCommonVersion>
-    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.22067.1</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
-    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.22067.1</MicrosoftDotNetXHarnessCLIVersion>
+    <MicrosoftDotNetXHarnessTestRunnersCommonVersion>1.0.0-prerelease.22071.1</MicrosoftDotNetXHarnessTestRunnersCommonVersion>
+    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.22071.1</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
+    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.22071.1</MicrosoftDotNetXHarnessCLIVersion>
     <MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>1.0.2-alpha.0.22069.1</MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>
     <XUnitVersion>2.4.2-pre.22</XUnitVersion>
     <XUnitAnalyzersVersion>0.12.0-pre.20</XUnitAnalyzersVersion>
@@ -180,7 +180,7 @@
     <MicrosoftNETILLinkTasksVersion>7.0.100-1.22063.2</MicrosoftNETILLinkTasksVersion>
     <MicrosoftNETILLinkAnalyzerPackageVersion>$(MicrosoftNETILLinkTasksVersion)</MicrosoftNETILLinkAnalyzerPackageVersion>
     <!-- ICU -->
-    <MicrosoftNETCoreRuntimeICUTransportVersion>7.0.0-alpha.1.22067.1</MicrosoftNETCoreRuntimeICUTransportVersion>
+    <MicrosoftNETCoreRuntimeICUTransportVersion>7.0.0-preview.2.22071.2</MicrosoftNETCoreRuntimeICUTransportVersion>
     <!-- MsQuic -->
     <SystemNetMsQuicTransportVersion>7.0.0-alpha.1.21529.3</SystemNetMsQuicTransportVersion>
     <!-- Mono LLVM -->
@@ -193,7 +193,7 @@
     <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22067.2</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
     <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22067.2</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
     <!-- emscripten / Node -->
-    <MicrosoftNETWorkloadEmscriptenManifest70100Version>7.0.0-alpha.1.21601.1</MicrosoftNETWorkloadEmscriptenManifest70100Version>
+    <MicrosoftNETWorkloadEmscriptenManifest70100Version>7.0.0-alpha.2.22071.3</MicrosoftNETWorkloadEmscriptenManifest70100Version>
     <MicrosoftNETRuntimeEmscriptenVersion>$(MicrosoftNETWorkloadEmscriptenManifest70100Version)</MicrosoftNETRuntimeEmscriptenVersion>
     <!-- workloads -->
     <SwixPackageVersion>1.1.87-gba258badda</SwixPackageVersion>
diff --git a/eng/common/internal/NuGet.config b/eng/common/internal/NuGet.config
new file mode 100644
index 00000000000000..769650362f4aa4
--- /dev/null
+++ b/eng/common/internal/NuGet.config
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <clear />
+    <add key="dotnet-core-internal" value="https://pkgs.dev.azure.com/devdiv/_packaging/dotnet-core-internal/nuget/v3/index.json" />
+  </packageSources>
+</configuration>
diff --git a/eng/common/templates/job/execute-sdl.yml b/eng/common/templates/job/execute-sdl.yml
index 8cf772b3cbf812..a4837c32c3869c 100644
--- a/eng/common/templates/job/execute-sdl.yml
+++ b/eng/common/templates/job/execute-sdl.yml
@@ -29,14 +29,6 @@ parameters:
   # Optional: download a list of pipeline artifacts. 'downloadArtifacts' controls build artifacts,
   # not pipeline artifacts, so doesn't affect the use of this parameter.
   pipelineArtifactNames: []
-  # Optional: location and ID of the AzDO build that the build/pipeline artifacts should be
-  # downloaded from. By default, uses runtime expressions to decide based on the variables set by
-  # the 'setupMaestroVars' dependency. Overriding this parameter is necessary if SDL tasks are
-  # running without Maestro++/BAR involved, or to download artifacts from a specific existing build
-  # to iterate quickly on SDL changes.
-  AzDOProjectName: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-  AzDOPipelineId: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-  AzDOBuildId: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
 
 jobs:
 - job: Run_SDL
@@ -55,11 +47,14 @@ jobs:
     - name: GuardianVersion
       value: ${{ coalesce(parameters.overrideGuardianVersion, '$(DefaultGuardianVersion)') }}
   pool:
-    vmImage: windows-2019
+    name: NetCore1ESPool-Internal
+    demands: ImageOverride -equals Build.Server.Amd64.VS2019
   steps:
   - checkout: self
     clean: true
 
+  - template: /eng/common/templates/post-build/setup-maestro-vars.yml
+
   - ${{ if ne(parameters.downloadArtifacts, 'false')}}:
     - ${{ if ne(parameters.artifactNames, '') }}:
       - ${{ each artifactName in parameters.artifactNames }}:
diff --git a/eng/common/templates/job/onelocbuild.yml b/eng/common/templates/job/onelocbuild.yml
index c4fc18b3ee77aa..0b93fd5b490ebb 100644
--- a/eng/common/templates/job/onelocbuild.yml
+++ b/eng/common/templates/job/onelocbuild.yml
@@ -4,7 +4,8 @@ parameters:
 
   # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
   pool:
-    vmImage: 'windows-2019'
+    name: NetCore1ESPool-Internal
+    demands: ImageOverride -equals Build.Server.Amd64.VS2019
 
   CeapexPat: $(dn-bot-ceapex-package-r) # PAT for the loc AzDO instance https://dev.azure.com/ceapex
   GithubPat: $(BotAccount-dotnet-bot-repo-PAT)
diff --git a/eng/common/templates/jobs/jobs.yml b/eng/common/templates/jobs/jobs.yml
index ff4ab75c886dc7..dafa603dc5d900 100644
--- a/eng/common/templates/jobs/jobs.yml
+++ b/eng/common/templates/jobs/jobs.yml
@@ -83,7 +83,9 @@ jobs:
         - ${{ if eq(parameters.enableSourceBuild, true) }}:
           - Source_Build_Complete
         pool:
-          vmImage: 'windows-2019'
+          name: NetCore1ESPool-Internal
+          demands: ImageOverride -equals Build.Server.Amd64.VS2019
+
         runAsPublic: ${{ parameters.runAsPublic }}
         publishUsingPipelines: ${{ parameters.enablePublishUsingPipelines }}
         enablePublishBuildArtifacts: ${{ parameters.enablePublishBuildArtifacts }}
diff --git a/eng/common/templates/post-build/common-variables.yml b/eng/common/templates/post-build/common-variables.yml
index c99fd7503767cd..c830e6f277606e 100644
--- a/eng/common/templates/post-build/common-variables.yml
+++ b/eng/common/templates/post-build/common-variables.yml
@@ -4,54 +4,6 @@ variables:
   - group: DotNet-DotNetCli-Storage
   - group: DotNet-MSRC-Storage
   - group: Publish-Build-Assets
-    
-  # .NET Core 3.1 Dev
-  - name: PublicDevRelease_31_Channel_Id
-    value: 128
-
-  # .NET 5 Dev
-  - name: Net_5_Dev_Channel_Id
-    value: 131
-
-  # .NET Eng - Validation
-  - name: Net_Eng_Validation_Channel_Id
-    value: 9
-
-  # .NET Eng - Latest
-  - name: Net_Eng_Latest_Channel_Id
-    value: 2
-
-  # .NET 3 Eng - Validation
-  - name: NET_3_Eng_Validation_Channel_Id
-    value: 390
-
-  # .NET 3 Eng
-  - name: NetCore_3_Tools_Channel_Id
-    value: 344
-
-  # .NET Core 3.0 Internal Servicing
-  - name: InternalServicing_30_Channel_Id
-    value: 184
-
-  # .NET Core 3.0 Release
-  - name: PublicRelease_30_Channel_Id
-    value: 19
-
-  # .NET Core 3.1 Release
-  - name: PublicRelease_31_Channel_Id
-    value: 129
-
-  # General Testing
-  - name: GeneralTesting_Channel_Id
-    value: 529
-
-  # .NET Core 3.1 Blazor Features
-  - name: NetCore_31_Blazor_Features_Channel_Id
-    value: 531
-
-  # .NET Core Experimental
-  - name: NetCore_Experimental_Channel_Id
-    value: 562
 
   # Whether the build is internal or not
   - name: IsInternalBuild
@@ -70,27 +22,6 @@ variables:
   - name: SymbolToolVersion
     value: 1.0.1
 
-  # Feed Configurations
-  # These should include the suffix "/index.json"
-
-  # Default locations for Installers and checksums
-  # Public Locations
-  - name: ChecksumsBlobFeedUrl
-    value: https://dotnetclichecksums.blob.core.windows.net/dotnet/index.json
-  - name: InstallersBlobFeedUrl
-    value: https://dotnetcli.blob.core.windows.net/dotnet/index.json
-
-  # Private Locations
-  - name: InternalChecksumsBlobFeedUrl
-    value: https://dotnetclichecksumsmsrc.blob.core.windows.net/dotnet/index.json
-  - name: InternalChecksumsBlobFeedKey
-    value: $(dotnetclichecksumsmsrc-storage-key)
-
-  - name: InternalInstallersBlobFeedUrl
-    value: https://dotnetclimsrc.blob.core.windows.net/dotnet/index.json
-  - name: InternalInstallersBlobFeedKey
-    value: $(dotnetclimsrc-access-key)
-
   # Skip component governance and codesign validation for SDL. These jobs
   # create no content.
   - name: skipComponentGovernanceDetection
diff --git a/eng/common/templates/post-build/post-build.yml b/eng/common/templates/post-build/post-build.yml
index 8985b429c85437..9583d27dbbf89d 100644
--- a/eng/common/templates/post-build/post-build.yml
+++ b/eng/common/templates/post-build/post-build.yml
@@ -90,25 +90,19 @@ stages:
     variables:
       - template: common-variables.yml
     jobs:
-    - template: setup-maestro-vars.yml
-      parameters:
-        BARBuildId: ${{ parameters.BARBuildId }}
-        PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
-
     - job:
       displayName: NuGet Validation
-      dependsOn: setupMaestroVars
       condition: eq( ${{ parameters.enableNugetValidation }}, 'true')
       pool:
-        vmImage: 'windows-2019'
-      variables:
-        - name: AzDOProjectName
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-        - name: AzDOPipelineId
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-        - name: AzDOBuildId
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
+        name: NetCore1ESPool-Internal
+        demands: ImageOverride -equals Build.Server.Amd64.VS2019
+
       steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
         - task: DownloadBuildArtifacts@0
           displayName: Download Package Artifacts
           inputs:
@@ -129,19 +123,16 @@ stages:
 
     - job:
       displayName: Signing Validation
-      dependsOn: setupMaestroVars
       condition: and( eq( ${{ parameters.enableSigningValidation }}, 'true'), ne( variables['PostBuildSign'], 'true'))
-      variables:
-        - template: common-variables.yml
-        - name: AzDOProjectName
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-        - name: AzDOPipelineId
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-        - name: AzDOBuildId
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
       pool:
-        vmImage: 'windows-2019'
+        name: NetCore1ESPool-Internal
+        demands: ImageOverride -equals Build.Server.Amd64.VS2019
       steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
         - task: DownloadBuildArtifacts@0
           displayName: Download Package Artifacts
           inputs:
@@ -186,19 +177,16 @@ stages:
 
     - job:
       displayName: SourceLink Validation
-      dependsOn: setupMaestroVars
       condition: eq( ${{ parameters.enableSourceLinkValidation }}, 'true')
-      variables:
-        - template: common-variables.yml
-        - name: AzDOProjectName
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOProjectName'] ]
-        - name: AzDOPipelineId
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOPipelineId'] ]
-        - name: AzDOBuildId
-          value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.AzDOBuildId'] ]
       pool:
-        vmImage: 'windows-2019'
+        name: NetCore1ESPool-Internal
+        demands: ImageOverride -equals Build.Server.Amd64.VS2019
       steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
         - task: DownloadBuildArtifacts@0
           displayName: Download Blob Artifacts
           inputs:
@@ -224,7 +212,6 @@ stages:
     - template: /eng/common/templates/job/execute-sdl.yml
       parameters:
         enable: ${{ parameters.SDLValidationParameters.enable }}
-        dependsOn: setupMaestroVars
         additionalParameters: ${{ parameters.SDLValidationParameters.params }}
         continueOnError: ${{ parameters.SDLValidationParameters.continueOnError }}
         artifactNames: ${{ parameters.SDLValidationParameters.artifactNames }}
@@ -239,21 +226,18 @@ stages:
   variables:
     - template: common-variables.yml
   jobs:
-  - template: setup-maestro-vars.yml
-    parameters:
-      BARBuildId: ${{ parameters.BARBuildId }}
-      PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
-
   - job:
     displayName: Publish Using Darc
-    dependsOn: setupMaestroVars
     timeoutInMinutes: 120
-    variables:
-      - name: BARBuildId
-        value: $[ dependencies.setupMaestroVars.outputs['setReleaseVars.BARBuildId'] ]
     pool:
-      vmImage: 'windows-2019'
+      name: NetCore1ESPool-Internal
+      demands: ImageOverride -equals Build.Server.Amd64.VS2019
     steps:
+      - template: setup-maestro-vars.yml
+        parameters:
+          BARBuildId: ${{ parameters.BARBuildId }}
+          PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
       - task: PowerShell@2
         displayName: Publish Using Darc
         inputs:
diff --git a/eng/common/templates/post-build/setup-maestro-vars.yml b/eng/common/templates/post-build/setup-maestro-vars.yml
index 4a22b2e6f6de79..826d3ed5f74c20 100644
--- a/eng/common/templates/post-build/setup-maestro-vars.yml
+++ b/eng/common/templates/post-build/setup-maestro-vars.yml
@@ -2,77 +2,68 @@ parameters:
   BARBuildId: ''
   PromoteToChannelIds: ''
 
-jobs:
-- job: setupMaestroVars
-  displayName: Setup Maestro Vars
-  variables:
-    - template: common-variables.yml
-  pool:
-    vmImage: 'windows-2019'
-  steps:
-    - checkout: none
-
-    - ${{ if eq(coalesce(parameters.PromoteToChannelIds, 0), 0) }}:
-      - task: DownloadBuildArtifacts@0
-        displayName: Download Release Configs
-        inputs:
-          buildType: current
-          artifactName: ReleaseConfigs
-          checkDownloadedFiles: true
-
-    - task: PowerShell@2
-      name: setReleaseVars
-      displayName: Set Release Configs Vars
+steps:
+  - ${{ if eq(coalesce(parameters.PromoteToChannelIds, 0), 0) }}:
+    - task: DownloadBuildArtifacts@0
+      displayName: Download Release Configs
       inputs:
-        targetType: inline
-        script: |
-          try {
-            if (!$Env:PromoteToMaestroChannels -or $Env:PromoteToMaestroChannels.Trim() -eq '') {
-              $Content = Get-Content $(Build.StagingDirectory)/ReleaseConfigs/ReleaseConfigs.txt
+        buildType: current
+        artifactName: ReleaseConfigs
+        checkDownloadedFiles: true
 
-              $BarId = $Content | Select -Index 0
-              $Channels = $Content | Select -Index 1             
-              $IsStableBuild = $Content | Select -Index 2
+  - task: PowerShell@2
+    name: setReleaseVars
+    displayName: Set Release Configs Vars
+    inputs:
+      targetType: inline
+      script: |
+        try {
+          if (!$Env:PromoteToMaestroChannels -or $Env:PromoteToMaestroChannels.Trim() -eq '') {
+            $Content = Get-Content $(Build.StagingDirectory)/ReleaseConfigs/ReleaseConfigs.txt
 
-              $AzureDevOpsProject = $Env:System_TeamProject
-              $AzureDevOpsBuildDefinitionId = $Env:System_DefinitionId
-              $AzureDevOpsBuildId = $Env:Build_BuildId
-            }
-            else {
-              $buildApiEndpoint = "${Env:MaestroApiEndPoint}/api/builds/${Env:BARBuildId}?api-version=${Env:MaestroApiVersion}"
+            $BarId = $Content | Select -Index 0
+            $Channels = $Content | Select -Index 1             
+            $IsStableBuild = $Content | Select -Index 2
 
-              $apiHeaders = New-Object 'System.Collections.Generic.Dictionary[[String],[String]]'
-              $apiHeaders.Add('Accept', 'application/json')
-              $apiHeaders.Add('Authorization',"Bearer ${Env:MAESTRO_API_TOKEN}")
-
-              $buildInfo = try { Invoke-WebRequest -Method Get -Uri $buildApiEndpoint -Headers $apiHeaders | ConvertFrom-Json } catch { Write-Host "Error: $_" }
-             
-              $BarId = $Env:BARBuildId
-              $Channels = $Env:PromoteToMaestroChannels -split ","
-              $Channels = $Channels -join "]["
-              $Channels = "[$Channels]"
+            $AzureDevOpsProject = $Env:System_TeamProject
+            $AzureDevOpsBuildDefinitionId = $Env:System_DefinitionId
+            $AzureDevOpsBuildId = $Env:Build_BuildId
+          }
+          else {
+            $buildApiEndpoint = "${Env:MaestroApiEndPoint}/api/builds/${Env:BARBuildId}?api-version=${Env:MaestroApiVersion}"
 
-              $IsStableBuild = $buildInfo.stable
-              $AzureDevOpsProject = $buildInfo.azureDevOpsProject
-              $AzureDevOpsBuildDefinitionId = $buildInfo.azureDevOpsBuildDefinitionId
-              $AzureDevOpsBuildId = $buildInfo.azureDevOpsBuildId
-            }
+            $apiHeaders = New-Object 'System.Collections.Generic.Dictionary[[String],[String]]'
+            $apiHeaders.Add('Accept', 'application/json')
+            $apiHeaders.Add('Authorization',"Bearer ${Env:MAESTRO_API_TOKEN}")
 
-            Write-Host "##vso[task.setvariable variable=BARBuildId;isOutput=true]$BarId"
-            Write-Host "##vso[task.setvariable variable=TargetChannels;isOutput=true]$Channels"
-            Write-Host "##vso[task.setvariable variable=IsStableBuild;isOutput=true]$IsStableBuild"
+            $buildInfo = try { Invoke-WebRequest -Method Get -Uri $buildApiEndpoint -Headers $apiHeaders | ConvertFrom-Json } catch { Write-Host "Error: $_" }
+            
+            $BarId = $Env:BARBuildId
+            $Channels = $Env:PromoteToMaestroChannels -split ","
+            $Channels = $Channels -join "]["
+            $Channels = "[$Channels]"
 
-            Write-Host "##vso[task.setvariable variable=AzDOProjectName;isOutput=true]$AzureDevOpsProject"
-            Write-Host "##vso[task.setvariable variable=AzDOPipelineId;isOutput=true]$AzureDevOpsBuildDefinitionId"
-            Write-Host "##vso[task.setvariable variable=AzDOBuildId;isOutput=true]$AzureDevOpsBuildId"
+            $IsStableBuild = $buildInfo.stable
+            $AzureDevOpsProject = $buildInfo.azureDevOpsProject
+            $AzureDevOpsBuildDefinitionId = $buildInfo.azureDevOpsBuildDefinitionId
+            $AzureDevOpsBuildId = $buildInfo.azureDevOpsBuildId
           }
-          catch {
-            Write-Host $_
-            Write-Host $_.Exception
-            Write-Host $_.ScriptStackTrace
-            exit 1
-          }
-      env:
-        MAESTRO_API_TOKEN: $(MaestroApiAccessToken)
-        BARBuildId: ${{ parameters.BARBuildId }}
-        PromoteToMaestroChannels: ${{ parameters.PromoteToChannelIds }}
+
+          Write-Host "##vso[task.setvariable variable=BARBuildId]$BarId"
+          Write-Host "##vso[task.setvariable variable=TargetChannels]$Channels"
+          Write-Host "##vso[task.setvariable variable=IsStableBuild]$IsStableBuild"
+
+          Write-Host "##vso[task.setvariable variable=AzDOProjectName]$AzureDevOpsProject"
+          Write-Host "##vso[task.setvariable variable=AzDOPipelineId]$AzureDevOpsBuildDefinitionId"
+          Write-Host "##vso[task.setvariable variable=AzDOBuildId]$AzureDevOpsBuildId"
+        }
+        catch {
+          Write-Host $_
+          Write-Host $_.Exception
+          Write-Host $_.ScriptStackTrace
+          exit 1
+        }
+    env:
+      MAESTRO_API_TOKEN: $(MaestroApiAccessToken)
+      BARBuildId: ${{ parameters.BARBuildId }}
+      PromoteToMaestroChannels: ${{ parameters.PromoteToChannelIds }}
diff --git a/global.json b/global.json
index 6e753c749b04a4..e0d86ef423d93f 100644
--- a/global.json
+++ b/global.json
@@ -12,10 +12,10 @@
     "python3": "3.7.1"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "7.0.0-beta.22068.3",
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22068.3",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22068.3",
-    "Microsoft.DotNet.SharedFramework.Sdk": "7.0.0-beta.22068.3",
+    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "7.0.0-beta.22071.6",
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22071.6",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22071.6",
+    "Microsoft.DotNet.SharedFramework.Sdk": "7.0.0-beta.22071.6",
     "Microsoft.Build.NoTargets": "3.1.0",
     "Microsoft.Build.Traversal": "3.0.23",
     "Microsoft.NET.Sdk.IL": "7.0.0-alpha.1.22066.4"

From 7435abedcdf4c82a32e2afbafdd05bbc8f11d8ef Mon Sep 17 00:00:00 2001
From: Eaton Zveare <eaton@eaton-works.com>
Date: Mon, 24 Jan 2022 04:14:20 -0500
Subject: [PATCH 024/161] Update zip extraction to never throw any exceptions
 when the LastWriteTime update fails (#63912)

---
 .../IO/Compression/ZipFileExtensions.ZipArchiveEntry.Extract.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libraries/System.IO.Compression.ZipFile/src/System/IO/Compression/ZipFileExtensions.ZipArchiveEntry.Extract.cs b/src/libraries/System.IO.Compression.ZipFile/src/System/IO/Compression/ZipFileExtensions.ZipArchiveEntry.Extract.cs
index 5d800c1f62ca71..fe725937441e24 100644
--- a/src/libraries/System.IO.Compression.ZipFile/src/System/IO/Compression/ZipFileExtensions.ZipArchiveEntry.Extract.cs
+++ b/src/libraries/System.IO.Compression.ZipFile/src/System/IO/Compression/ZipFileExtensions.ZipArchiveEntry.Extract.cs
@@ -83,7 +83,7 @@ public static void ExtractToFile(this ZipArchiveEntry source, string destination
             {
                 File.SetLastWriteTime(destinationFileName, source.LastWriteTime.DateTime);
             }
-            catch (UnauthorizedAccessException)
+            catch
             {
                 // some OSes like Android (#35374) might not support setting the last write time, the extraction should not fail because of that
             }

From 11991bb444daaad255aa0a898a10e9c7b552dbc6 Mon Sep 17 00:00:00 2001
From: Eirik Tsarpalis <eirik.tsarpalis@gmail.com>
Date: Mon, 24 Jan 2022 09:58:24 +0000
Subject: [PATCH 025/161] Use kebab-case in FB automation labels (#64048)

---
 .github/fabricbot.json | 130 ++++++++++++++++++++---------------------
 1 file changed, 65 insertions(+), 65 deletions(-)

diff --git a/.github/fabricbot.json b/.github/fabricbot.json
index 723e3f5c493f2f..4679bc697e3756 100644
--- a/.github/fabricbot.json
+++ b/.github/fabricbot.json
@@ -996,7 +996,7 @@
     "subCapability": "IssueCommentResponder",
     "version": "1.0",
     "config": {
-      "taskName": "Replace `needs-author-action` label with `needs further triage` label when the author comments on an issue",
+      "taskName": "Replace `needs-author-action` label with `needs-further-triage` label when the author comments on an issue",
       "conditions": {
         "operator": "and",
         "operands": [
@@ -1030,7 +1030,7 @@
         {
           "name": "addLabel",
           "parameters": {
-            "label": "needs further triage"
+            "label": "needs-further-triage"
           }
         },
         {
@@ -1052,7 +1052,7 @@
     "subCapability": "IssuesOnlyResponder",
     "version": "1.0",
     "config": {
-      "taskName": "Remove `no recent activity` label from issues when issue is modified",
+      "taskName": "Remove `no-recent-activity` label from issues when issue is modified",
       "conditions": {
         "operator": "and",
         "operands": [
@@ -1070,7 +1070,7 @@
           {
             "name": "hasLabel",
             "parameters": {
-              "label": "no recent activity"
+              "label": "no-recent-activity"
             }
           },
           {
@@ -1079,7 +1079,7 @@
               {
                 "name": "labelAdded",
                 "parameters": {
-                  "label": "no recent activity"
+                  "label": "no-recent-activity"
                 }
               }
             ]
@@ -1090,7 +1090,7 @@
         {
           "name": "removeLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         }
       ],
@@ -1107,14 +1107,14 @@
     "subCapability": "IssueCommentResponder",
     "version": "1.0",
     "config": {
-      "taskName": "Remove `no recent activity` label when an issue is commented on",
+      "taskName": "Remove `no-recent-activity` label when an issue is commented on",
       "conditions": {
         "operator": "and",
         "operands": [
           {
             "name": "hasLabel",
             "parameters": {
-              "label": "no recent activity"
+              "label": "no-recent-activity"
             }
           }
         ]
@@ -1123,7 +1123,7 @@
         {
           "name": "removeLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         }
       ],
@@ -1149,7 +1149,7 @@
           {
             "name": "hasLabel",
             "parameters": {
-              "label": "no recent activity"
+              "label": "no-recent-activity"
             }
           },
           {
@@ -1158,7 +1158,7 @@
               {
                 "name": "labelAdded",
                 "parameters": {
-                  "label": "no recent activity"
+                  "label": "no-recent-activity"
                 }
               }
             ]
@@ -1171,12 +1171,12 @@
         "issues",
         "project_card"
       ],
-      "taskName": "Remove `no recent activity` label from PRs when modified",
+      "taskName": "Remove `no-recent-activity` label from PRs when modified",
       "actions": [
         {
           "name": "removeLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         }
       ]
@@ -1194,7 +1194,7 @@
           {
             "name": "hasLabel",
             "parameters": {
-              "label": "no recent activity"
+              "label": "no-recent-activity"
             }
           },
           {
@@ -1207,12 +1207,12 @@
       "eventNames": [
         "issue_comment"
       ],
-      "taskName": "Remove `no recent activity` label from PRs when commented on",
+      "taskName": "Remove `no-recent-activity` label from PRs when commented on",
       "actions": [
         {
           "name": "removeLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         }
       ]
@@ -1230,7 +1230,7 @@
           {
             "name": "hasLabel",
             "parameters": {
-              "label": "no recent activity"
+              "label": "no-recent-activity"
             }
           },
           {
@@ -1243,12 +1243,12 @@
       "eventNames": [
         "pull_request_review"
       ],
-      "taskName": "Remove `no recent activity` label from PRs when new review is added",
+      "taskName": "Remove `no-recent-activity` label from PRs when new review is added",
       "actions": [
         {
           "name": "removeLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         }
       ]
@@ -1345,7 +1345,7 @@
         {
           "name": "hasLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         },
         {
@@ -1359,7 +1359,7 @@
         {
           "name": "addReply",
           "parameters": {
-            "comment": "This issue will now be closed since it had been marked `no recent activity` but received no further activity in the past 14 days. It is still possible to reopen or comment on the issue, but please note that the issue will be locked if it remains inactive for another 30 days."
+            "comment": "This issue will now be closed since it had been marked `no-recent-activity` but received no further activity in the past 14 days. It is still possible to reopen or comment on the issue, but please note that the issue will be locked if it remains inactive for another 30 days."
           }
         },
         {
@@ -1375,7 +1375,7 @@
     "subCapability": "ScheduledSearch",
     "version": "1.1",
     "config": {
-      "taskName": "Close PRs with no recent activity",
+      "taskName": "Close PRs with no-recent-activity",
       "frequency": [
         {
           "weekDay": 0,
@@ -1460,7 +1460,7 @@
         {
           "name": "hasLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         },
         {
@@ -1474,7 +1474,7 @@
         {
           "name": "addReply",
           "parameters": {
-            "comment": "This pull request will now be closed since it had been marked `no recent activity` but received no further activity in the past 14 days. It is still possible to reopen or comment on the pull request, but please note that it will be locked if it remains inactive for another 30 days."
+            "comment": "This pull request will now be closed since it had been marked `no-recent-activity` but received no further activity in the past 14 days. It is still possible to reopen or comment on the pull request, but please note that it will be locked if it remains inactive for another 30 days."
           }
         },
         {
@@ -1490,7 +1490,7 @@
     "subCapability": "ScheduledSearch",
     "version": "1.1",
     "config": {
-      "taskName": "Add no recent activity label to issues",
+      "taskName": "Add no-recent-activity label to issues",
       "frequency": [
         {
           "weekDay": 0,
@@ -1587,7 +1587,7 @@
         {
           "name": "noLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         }
       ],
@@ -1595,13 +1595,13 @@
         {
           "name": "addLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         },
         {
           "name": "addReply",
           "parameters": {
-            "comment": "This issue has been automatically marked `no recent activity` because it has not had any activity for 14 days. It will be closed if no further activity occurs within 14 more days. Any new comment (by anyone, not necessarily the author) will remove `no recent activity`."
+            "comment": "This issue has been automatically marked `no-recent-activity` because it has not had any activity for 14 days. It will be closed if no further activity occurs within 14 more days. Any new comment (by anyone, not necessarily the author) will remove `no-recent-activity`."
           }
         }
       ]
@@ -1614,7 +1614,7 @@
     "subCapability": "ScheduledSearch",
     "version": "1.1",
     "config": {
-      "taskName": "Add no recent activity label to PRs",
+      "taskName": "Add no-recent-activity label to PRs",
       "frequency": [
         {
           "weekDay": 0,
@@ -1711,7 +1711,7 @@
         {
           "name": "noLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         }
       ],
@@ -1719,13 +1719,13 @@
         {
           "name": "addLabel",
           "parameters": {
-            "label": "no recent activity"
+            "label": "no-recent-activity"
           }
         },
         {
           "name": "addReply",
           "parameters": {
-            "comment": "This pull request has been automatically marked `no recent activity` because it has not had any activity for 14 days. It will be closed if no further activity occurs within 14 more days. Any new comment (by anyone, not necessarily the author) will remove `no recent activity`."
+            "comment": "This pull request has been automatically marked `no-recent-activity` because it has not had any activity for 14 days. It will be closed if no further activity occurs within 14 more days. Any new comment (by anyone, not necessarily the author) will remove `no-recent-activity`."
           }
         }
       ]
@@ -1742,7 +1742,7 @@
       "inPrLabelText": "Status: In PR",
       "fixedLabelText": "Status: Fixed",
       "fixedLabelEnabled": false,
-      "label_inPr": "in pr"
+      "label_inPr": "in-pr"
     }
   },
   {
@@ -2239,7 +2239,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -2267,7 +2267,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -2280,7 +2280,7 @@
                   {
                     "name": "labelRemoved",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   },
                   {
@@ -2502,7 +2502,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -2524,7 +2524,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -2543,7 +2543,7 @@
                   {
                     "name": "labelRemoved",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   },
                   {
@@ -2625,7 +2625,7 @@
               {
                 "name": "labelAdded",
                 "parameters": {
-                  "label": "needs further triage"
+                  "label": "needs-further-triage"
                 }
               },
               {
@@ -2928,7 +2928,7 @@
         {
           "name": "addLabel",
           "parameters": {
-            "label": "needs further triage"
+            "label": "needs-further-triage"
           }
         }
       ]
@@ -3006,7 +3006,7 @@
         {
           "name": "addLabel",
           "parameters": {
-            "label": "needs further triage"
+            "label": "needs-further-triage"
           }
         }
       ]
@@ -3130,7 +3130,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -3152,7 +3152,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -3171,7 +3171,7 @@
                   {
                     "name": "labelRemoved",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   },
                   {
@@ -3258,7 +3258,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -3280,7 +3280,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -3299,7 +3299,7 @@
                   {
                     "name": "labelRemoved",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   },
                   {
@@ -3369,7 +3369,7 @@
               {
                 "name": "labelRemoved",
                 "parameters": {
-                  "label": "needs further triage"
+                  "label": "needs-further-triage"
                 }
               },
               {
@@ -3398,7 +3398,7 @@
                   {
                     "name": "hasLabel",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   }
                 ]
@@ -3837,7 +3837,7 @@
               {
                 "name": "labelAdded",
                 "parameters": {
-                  "label": "needs further triage"
+                  "label": "needs-further-triage"
                 }
               },
               {
@@ -3989,7 +3989,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -4018,7 +4018,7 @@
                   {
                     "name": "hasLabel",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   }
                 ]
@@ -4029,7 +4029,7 @@
                   {
                     "name": "labelRemoved",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   },
                   {
@@ -4210,7 +4210,7 @@
               {
                 "name": "labelAdded",
                 "parameters": {
-                  "label": "needs further triage"
+                  "label": "needs-further-triage"
                 }
               },
               {
@@ -4317,7 +4317,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -4350,7 +4350,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -4369,7 +4369,7 @@
                   {
                     "name": "labelRemoved",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   },
                   {
@@ -5159,7 +5159,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -5187,7 +5187,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -5215,7 +5215,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -5287,7 +5287,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -5315,7 +5315,7 @@
                       {
                         "name": "hasLabel",
                         "parameters": {
-                          "label": "needs further triage"
+                          "label": "needs-further-triage"
                         }
                       }
                     ]
@@ -5328,7 +5328,7 @@
                   {
                     "name": "labelRemoved",
                     "parameters": {
-                      "label": "needs further triage"
+                      "label": "needs-further-triage"
                     }
                   },
                   {
@@ -5383,7 +5383,7 @@
           {
             "name": "labelAdded",
             "parameters": {
-              "label": "no recent activity"
+              "label": "no-recent-activity"
             }
           }
         ]

From 42c29676a715c7bf7e61411c7e9e3746626cc7a5 Mon Sep 17 00:00:00 2001
From: Eirik Tsarpalis <eirik.tsarpalis@gmail.com>
Date: Mon, 24 Jan 2022 10:23:01 +0000
Subject: [PATCH 026/161] Onboard new Triage & PR Boards (#64198)

---
 .github/fabricbot.json | 1452 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1452 insertions(+)

diff --git a/.github/fabricbot.json b/.github/fabricbot.json
index 4679bc697e3756..030256bef724d4 100644
--- a/.github/fabricbot.json
+++ b/.github/fabricbot.json
@@ -8524,5 +8524,1457 @@
         }
       ]
     }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssuesOnlyResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "operator": "and",
+                "operands": [
+                  {
+                    "operator": "or",
+                    "operands": [
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-Infrastructure-libraries"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-Microsoft.Win32"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Diagnostics.EventLog"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Diagnostics.PerformanceCounter"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Diagnostics.TraceSource"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Drawing"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Management"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.ServiceProcess"
+                        }
+                      }
+                    ]
+                  },
+                  {
+                    "operator": "or",
+                    "operands": [
+                      {
+                        "name": "isAction",
+                        "parameters": {
+                          "action": "reopened"
+                        }
+                      },
+                      {
+                        "operator": "not",
+                        "operands": [
+                          {
+                            "name": "isInMilestone",
+                            "parameters": {}
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              },
+              {
+                "operator": "or",
+                "operands": [
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-Infrastructure-libraries"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-Microsoft.Win32"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.EventLog"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.PerformanceCounter"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.TraceSource"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Drawing"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Management"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.ServiceProcess"
+                    }
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "name": "isOpen",
+            "parameters": {}
+          },
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "isInProject",
+                    "parameters": {
+                      "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+                      "isOrgProject": true
+                    }
+                  }
+                ]
+              },
+              {
+                "name": "isInProjectColumn",
+                "parameters": {
+                  "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+                  "isOrgProject": true,
+                  "columnName": "Triaged"
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Carlos / Santi - Issue Triage] Add new issue to Board",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+            "columnName": "Needs Triage",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssueCommentResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-Infrastructure-libraries"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-Microsoft.Win32"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.EventLog"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.PerformanceCounter"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.TraceSource"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Drawing"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Management"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.ServiceProcess"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "isCloseAndComment",
+                "parameters": {}
+              }
+            ]
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "activitySenderHasPermissions",
+                "parameters": {
+                  "permissions": "write"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "isInProject",
+                    "parameters": {
+                      "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+                      "isOrgProject": true
+                    }
+                  }
+                ]
+              },
+              {
+                "name": "isInProjectColumn",
+                "parameters": {
+                  "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+                  "columnName": "Triaged",
+                  "isOrgProject": true
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issue_comment"
+      ],
+      "taskName": "[Area Pod: Carlos / Santi - Issue Triage] Needs Further Triage",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+            "columnName": "Needs Triage",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssuesOnlyResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "name": "isInProjectColumn",
+            "parameters": {
+              "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+              "columnName": "Needs Triage",
+              "isOrgProject": true
+            }
+          },
+          {
+            "operator": "and",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-Infrastructure-libraries"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-Microsoft.Win32"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.EventLog"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.PerformanceCounter"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.TraceSource"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Drawing"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Management"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.ServiceProcess"
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Carlos / Santi - Issue Triage] Remove relabeled issues",
+      "actions": [
+        {
+          "name": "removeFromProject",
+          "parameters": {
+            "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssuesOnlyResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "name": "isInProject",
+            "parameters": {
+              "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+              "isOrgProject": true
+            }
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "isInProjectColumn",
+                "parameters": {
+                  "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+                  "columnName": "Triaged"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "name": "addedToMilestone",
+                "parameters": {}
+              },
+              {
+                "name": "labelAdded",
+                "parameters": {
+                  "label": "needs-author-action"
+                }
+              },
+              {
+                "name": "labelAdded",
+                "parameters": {
+                  "label": "api-ready-for-review"
+                }
+              },
+              {
+                "name": "isAction",
+                "parameters": {
+                  "action": "closed"
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Carlos / Santi - Issue Triage] Move to Triaged Column",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Carlos / Santi - Issue Triage",
+            "columnName": "Triaged",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "PullRequestResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-Infrastructure-libraries"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-Microsoft.Win32"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.EventLog"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.PerformanceCounter"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.TraceSource"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Drawing"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Management"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.ServiceProcess"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "isInProject",
+                "parameters": {
+                  "projectName": "Area Pod: Carlos / Santi - PRs",
+                  "isOrgProject": true
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "pull_request",
+      "eventNames": [
+        "pull_request",
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Carlos / Santi - PRs] Add new PR to Board",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Carlos / Santi - PRs",
+            "columnName": "Needs Champion",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "PullRequestResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "name": "isInProjectColumn",
+            "parameters": {
+              "projectName": "Area Pod: Carlos / Santi - PRs",
+              "columnName": "Needs Champion",
+              "isOrgProject": true
+            }
+          },
+          {
+            "operator": "and",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-Infrastructure-libraries"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-Microsoft.Win32"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.EventLog"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.PerformanceCounter"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.TraceSource"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Drawing"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Management"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.ServiceProcess"
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "pull_request",
+      "eventNames": [
+        "pull_request",
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Carlos / Santi - PRs] Remove relabeled PRs",
+      "actions": [
+        {
+          "name": "removeFromProject",
+          "parameters": {
+            "projectName": "Area Pod: Carlos / Santi - PRs",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssuesOnlyResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "operator": "and",
+                "operands": [
+                  {
+                    "operator": "or",
+                    "operands": [
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-Extensions-FileSystem"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Console"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Diagnostics.Process"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.IO"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.IO.Compression"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Linq.Parallel"
+                        }
+                      },
+                      {
+                        "name": "hasLabel",
+                        "parameters": {
+                          "label": "area-System.Memory"
+                        }
+                      }
+                    ]
+                  },
+                  {
+                    "operator": "or",
+                    "operands": [
+                      {
+                        "name": "isAction",
+                        "parameters": {
+                          "action": "reopened"
+                        }
+                      },
+                      {
+                        "operator": "not",
+                        "operands": [
+                          {
+                            "name": "isInMilestone",
+                            "parameters": {}
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              },
+              {
+                "operator": "or",
+                "operands": [
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-Extensions-FileSystem"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Console"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.Process"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.IO"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.IO.Compression"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Linq.Parallel"
+                    }
+                  },
+                  {
+                    "name": "labelAdded",
+                    "parameters": {
+                      "label": "area-System.Memory"
+                    }
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "name": "isOpen",
+            "parameters": {}
+          },
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "isInProject",
+                    "parameters": {
+                      "projectName": "Area Pod: Adam / David - Issue Triage",
+                      "isOrgProject": true
+                    }
+                  }
+                ]
+              },
+              {
+                "name": "isInProjectColumn",
+                "parameters": {
+                  "projectName": "Area Pod: Adam / David - Issue Triage",
+                  "isOrgProject": true,
+                  "columnName": "Triaged"
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Adam / David - Issue Triage] Add new issue to Board",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Adam / David - Issue Triage",
+            "columnName": "Needs Triage",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssueCommentResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-Extensions-FileSystem"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Console"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.Process"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.IO"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.IO.Compression"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Linq.Parallel"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Memory"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "isCloseAndComment",
+                "parameters": {}
+              }
+            ]
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "activitySenderHasPermissions",
+                "parameters": {
+                  "permissions": "write"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "isInProject",
+                    "parameters": {
+                      "projectName": "Area Pod: Adam / David - Issue Triage",
+                      "isOrgProject": true
+                    }
+                  }
+                ]
+              },
+              {
+                "name": "isInProjectColumn",
+                "parameters": {
+                  "projectName": "Area Pod: Adam / David - Issue Triage",
+                  "columnName": "Triaged",
+                  "isOrgProject": true
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issue_comment"
+      ],
+      "taskName": "[Area Pod: Adam / David - Issue Triage] Needs Further Triage",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Adam / David - Issue Triage",
+            "columnName": "Needs Triage",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssuesOnlyResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "name": "isInProjectColumn",
+            "parameters": {
+              "projectName": "Area Pod: Adam / David - Issue Triage",
+              "columnName": "Needs Triage",
+              "isOrgProject": true
+            }
+          },
+          {
+            "operator": "and",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-Extensions-FileSystem"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Console"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.Process"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.IO"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.IO.Compression"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Linq.Parallel"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Memory"
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Adam / David - Issue Triage] Remove relabeled issues",
+      "actions": [
+        {
+          "name": "removeFromProject",
+          "parameters": {
+            "projectName": "Area Pod: Adam / David - Issue Triage",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "IssuesOnlyResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "name": "isInProject",
+            "parameters": {
+              "projectName": "Area Pod: Adam / David - Issue Triage",
+              "isOrgProject": true
+            }
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "isInProjectColumn",
+                "parameters": {
+                  "projectName": "Area Pod: Adam / David - Issue Triage",
+                  "columnName": "Triaged"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "name": "addedToMilestone",
+                "parameters": {}
+              },
+              {
+                "name": "labelAdded",
+                "parameters": {
+                  "label": "needs-author-action"
+                }
+              },
+              {
+                "name": "labelAdded",
+                "parameters": {
+                  "label": "api-ready-for-review"
+                }
+              },
+              {
+                "name": "isAction",
+                "parameters": {
+                  "action": "closed"
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "issue",
+      "eventNames": [
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Adam / David - Issue Triage] Move to Triaged Column",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Adam / David - Issue Triage",
+            "columnName": "Triaged",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "PullRequestResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "operator": "or",
+            "operands": [
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-Extensions-FileSystem"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Console"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Diagnostics.Process"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.IO"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.IO.Compression"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Linq.Parallel"
+                }
+              },
+              {
+                "name": "hasLabel",
+                "parameters": {
+                  "label": "area-System.Memory"
+                }
+              }
+            ]
+          },
+          {
+            "operator": "not",
+            "operands": [
+              {
+                "name": "isInProject",
+                "parameters": {
+                  "projectName": "Area Pod: Adam / David - PRs",
+                  "isOrgProject": true
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "pull_request",
+      "eventNames": [
+        "pull_request",
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Adam / David - PRs] Add new PR to Board",
+      "actions": [
+        {
+          "name": "addToProject",
+          "parameters": {
+            "projectName": "Area Pod: Adam / David - PRs",
+            "columnName": "Needs Champion",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
+  },
+  {
+    "taskType": "trigger",
+    "capabilityId": "IssueResponder",
+    "subCapability": "PullRequestResponder",
+    "version": "1.0",
+    "config": {
+      "conditions": {
+        "operator": "and",
+        "operands": [
+          {
+            "name": "isInProjectColumn",
+            "parameters": {
+              "projectName": "Area Pod: Adam / David - PRs",
+              "columnName": "Needs Champion",
+              "isOrgProject": true
+            }
+          },
+          {
+            "operator": "and",
+            "operands": [
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-Extensions-FileSystem"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Console"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Diagnostics.Process"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.IO"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.IO.Compression"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Linq.Parallel"
+                    }
+                  }
+                ]
+              },
+              {
+                "operator": "not",
+                "operands": [
+                  {
+                    "name": "hasLabel",
+                    "parameters": {
+                      "label": "area-System.Memory"
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      "eventType": "pull_request",
+      "eventNames": [
+        "pull_request",
+        "issues",
+        "project_card"
+      ],
+      "taskName": "[Area Pod: Adam / David - PRs] Remove relabeled PRs",
+      "actions": [
+        {
+          "name": "removeFromProject",
+          "parameters": {
+            "projectName": "Area Pod: Adam / David - PRs",
+            "isOrgProject": true
+          }
+        }
+      ]
+    }
   }
 ]
\ No newline at end of file

From 773e822f66ca5d67b3d6e54adf63fb63c346eb34 Mon Sep 17 00:00:00 2001
From: Jeff Handley <jeffhandley@users.noreply.github.com>
Date: Mon, 24 Jan 2022 02:48:35 -0800
Subject: [PATCH 027/161] Exclusively use GitHub teams for Libraries area
 mentions (#64199)

---
 .github/fabricbot.json | 21 +++++++--------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/.github/fabricbot.json b/.github/fabricbot.json
index 030256bef724d4..accae195f26ee0 100644
--- a/.github/fabricbot.json
+++ b/.github/fabricbot.json
@@ -13,8 +13,7 @@
           ],
           "mentionees": [
             "dotnet/area-system-security",
-            "vcsjones",
-            "krwq"
+            "vcsjones"
           ]
         },
         {
@@ -33,8 +32,7 @@
             "area-System.Linq.Parallel"
           ],
           "mentionees": [
-            "dotnet/area-system-linq-parallel",
-            "tarekgh"
+            "dotnet/area-system-linq-parallel"
           ]
         },
         {
@@ -42,8 +40,7 @@
             "area-System.Text.Encoding"
           ],
           "mentionees": [
-            "dotnet/area-system-text-encoding",
-            "tarekgh"
+            "dotnet/area-system-text-encoding"
           ]
         },
         {
@@ -51,8 +48,7 @@
             "area-System.Text.Encodings.Web"
           ],
           "mentionees": [
-            "dotnet/area-system-text-encodings-web",
-            "tarekgh"
+            "dotnet/area-system-text-encodings-web"
           ]
         },
         {
@@ -175,8 +171,7 @@
             "area-System.Buffers"
           ],
           "mentionees": [
-            "dotnet/area-system-buffers",
-            "GrabYourPitchforks"
+            "dotnet/area-system-buffers"
           ]
         },
         {
@@ -377,8 +372,7 @@
             "area-Extensions-FileSystem"
           ],
           "mentionees": [
-            "dotnet/area-extensions-filesystem",
-            "maryamariyan"
+            "dotnet/area-extensions-filesystem"
           ]
         },
         {
@@ -776,8 +770,7 @@
             "area-System.Resources"
           ],
           "mentionees": [
-            "dotnet/area-system-resources",
-            "tarekgh"
+            "dotnet/area-system-resources"
           ]
         },
         {

From d964b638f1ad47a729ab2e6cf4d6822f76ea3e4f Mon Sep 17 00:00:00 2001
From: Christopher Moore <chrisdcmoore@users.noreply.github.com>
Date: Mon, 24 Jan 2022 12:53:54 +0000
Subject: [PATCH 028/161] Reduce buffer size used in XmlReader when using Async
 mode (#63459)

The current choice of AsyncBufferSize resulted in the character buffer in the XmlTextReader being allocated on the Large Object Heap (LOH)

Fixes https://github.com/dotnet/runtime/issues/61459
---
 .../System.Private.Xml/src/System/Xml/Core/XmlReader.cs       | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs
index c6a6c1ce3e32f4..599ff04f757fd1 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs
@@ -81,7 +81,9 @@ public abstract partial class XmlReader : IDisposable
         internal const int BiggerBufferSize = 8192;
         internal const int MaxStreamLengthForDefaultBufferSize = 64 * 1024; // 64kB
 
-        internal const int AsyncBufferSize = 64 * 1024; //64KB
+        // Chosen to be small enough that the character buffer in XmlTextReader when using Async = true
+        // is not allocated on the Large Object Heap (LOH)
+        internal const int AsyncBufferSize = 32 * 1024;
 
         // Settings
         public virtual XmlReaderSettings? Settings => null;

From 0a9aecb192e76e7bdf02cead9f93deadbcd2382e Mon Sep 17 00:00:00 2001
From: Katya Sokolova <esokolov@microsoft.com>
Date: Mon, 24 Jan 2022 15:02:05 +0100
Subject: [PATCH 029/161] Ignoring leading dot when comparing cookie domains
 (#64038)

* ignoring leading dot when comparin cookie domain

* Simplify cookie comparing logic to equality and moving it to CookieComparer to fix the build

* Domain comparing optimizarion and more unit tests

* small check optimization

* Renaming method
---
 .../Common/src/System/Net/CookieComparer.cs   | 22 +++++----
 .../src/System/Net/Cookie.cs                  |  2 +-
 .../src/System/Net/CookieCollection.cs        |  4 +-
 .../tests/UnitTests/CookieContainerTest.cs    | 45 +++++++++++++++++++
 4 files changed, 62 insertions(+), 11 deletions(-)

diff --git a/src/libraries/Common/src/System/Net/CookieComparer.cs b/src/libraries/Common/src/System/Net/CookieComparer.cs
index 7d511ace0a9acc..529ec06a51a1fe 100644
--- a/src/libraries/Common/src/System/Net/CookieComparer.cs
+++ b/src/libraries/Common/src/System/Net/CookieComparer.cs
@@ -5,23 +5,29 @@ namespace System.Net
 {
     internal static class CookieComparer
     {
-        internal static int Compare(Cookie left, Cookie right)
+        internal static bool Equals(Cookie left, Cookie right)
         {
-            int result;
-
-            if ((result = string.Compare(left.Name, right.Name, StringComparison.OrdinalIgnoreCase)) != 0)
+            if (!string.Equals(left.Name, right.Name, StringComparison.OrdinalIgnoreCase))
             {
-                return result;
+                return false;
             }
 
-            if ((result = string.Compare(left.Domain, right.Domain, StringComparison.OrdinalIgnoreCase)) != 0)
+            if (!EqualDomains(left.Domain, right.Domain))
             {
-                return result;
+                return false;
             }
 
             // NB: Only the path is case sensitive as per spec. However, many Windows applications assume
             //     case-insensitivity.
-            return string.Compare(left.Path, right.Path, StringComparison.Ordinal);
+            return string.Equals(left.Path, right.Path, StringComparison.Ordinal);
+        }
+
+        internal static bool EqualDomains(ReadOnlySpan<char> left, ReadOnlySpan<char> right)
+        {
+            if (left.Length != 0 && left[0] == '.') left = left.Slice(1);
+            if (right.Length != 0 && right[0] == '.') right = right.Slice(1);
+
+            return left.Equals(right, StringComparison.OrdinalIgnoreCase);
         }
     }
 }
diff --git a/src/libraries/System.Net.Primitives/src/System/Net/Cookie.cs b/src/libraries/System.Net.Primitives/src/System/Net/Cookie.cs
index 8ed63ef9f97b3b..4d0bfa918fd242 100644
--- a/src/libraries/System.Net.Primitives/src/System/Net/Cookie.cs
+++ b/src/libraries/System.Net.Primitives/src/System/Net/Cookie.cs
@@ -717,7 +717,7 @@ public override bool Equals([NotNullWhen(true)] object? comparand)
                     && string.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase)
                     && string.Equals(Value, other.Value, StringComparison.Ordinal)
                     && string.Equals(Path, other.Path, StringComparison.Ordinal)
-                    && string.Equals(Domain, other.Domain, StringComparison.OrdinalIgnoreCase)
+                    && CookieComparer.EqualDomains(Domain, other.Domain)
                     && (Version == other.Version);
         }
 
diff --git a/src/libraries/System.Net.Primitives/src/System/Net/CookieCollection.cs b/src/libraries/System.Net.Primitives/src/System/Net/CookieCollection.cs
index e8c7c78b68c0b5..edfe5ce52551ae 100644
--- a/src/libraries/System.Net.Primitives/src/System/Net/CookieCollection.cs
+++ b/src/libraries/System.Net.Primitives/src/System/Net/CookieCollection.cs
@@ -203,7 +203,7 @@ internal int InternalAdd(Cookie cookie, bool isStrict)
                 for (int i = 0; i < listCount; i++)
                 {
                     Cookie c = (Cookie)m_list[i]!;
-                    if (CookieComparer.Compare(cookie, c) == 0)
+                    if (CookieComparer.Equals(cookie, c))
                     {
                         ret = 0; // Will replace or reject
 
@@ -237,7 +237,7 @@ internal int IndexOf(Cookie cookie)
             int idx = 0;
             foreach (Cookie? c in m_list)
             {
-                if (CookieComparer.Compare(cookie, c!) == 0)
+                if (CookieComparer.Equals(cookie, c!))
                 {
                     return idx;
                 }
diff --git a/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs b/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs
index b3673331aebcd6..53cb06963caa7f 100644
--- a/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs
+++ b/src/libraries/System.Net.Primitives/tests/UnitTests/CookieContainerTest.cs
@@ -866,6 +866,51 @@ public void SetCookies_DomainCheckFailure_IgnoresAbsenceOfLeadingDot(string doma
             Assert.Throws<CookieException>(() => container.SetCookies(uri, cookie));
         }
 
+        [Theory]
+        [InlineData("example.com", "example.com"  )]
+        [InlineData("example.com", ".example.com" )]
+        [InlineData(".example.com", "example.com" )]
+        [InlineData(".example.com", ".example.com")]
+        public void SetCookies_DomainCheckSuccess_IgnoresLeadingDot(params string[] domains)
+        {
+            var uri = new Uri($"https://{domains[0].Trim('.')}/", UriKind.Absolute);
+            var container = new CookieContainer();
+
+            // First HTTP response...
+            container.SetCookies(uri, $"foo=bar; Path=/; Domain={domains[0]}");
+
+            // Second HTTP response...
+            container.SetCookies(uri, $"foo=baz; Path=/; Domain={domains[1]}");
+
+            CookieCollection acceptedCookies = container.GetCookies(uri);
+            Assert.Equal(1, acceptedCookies.Count);
+            Assert.Equal(domains[1], acceptedCookies[0].Domain);
+        }
+
+        [Theory]
+        [InlineData("test.example.com", "example.com")]
+        [InlineData("test.example.com", ".example.com")]
+        [InlineData("example.com", "test.example.com")]
+        [InlineData(".example.com", "test.example.com")]
+        public void SetCookies_DomainCheckFailure_IgnoresLeadingDot(params string[] domains)
+        {
+            var uri = new Uri($"https://test.example.com/", UriKind.Absolute);
+            var container = new CookieContainer();
+
+            // First HTTP response...
+            container.SetCookies(uri, $"foo=bar; Path=/; Domain={domains[0]}");
+
+            // Second HTTP response...
+            container.SetCookies(uri, $"foo=baz; Path=/; Domain={domains[1]}");
+
+            CookieCollection acceptedCookies = container.GetCookies(uri);
+            Assert.Equal(2, acceptedCookies.Count);
+            foreach (Cookie cookie in acceptedCookies)
+            {
+                Assert.Contains(cookie.Domain, domains);
+            }
+        }
+
         // Test default-path calculation as defined in
         // https://tools.ietf.org/html/rfc6265#section-5.1.4
         public static readonly TheoryData<string, string> DefaultPathData = new TheoryData<string, string>()

From 65b12267400471f1c11e9a396250a6beb3b495a2 Mon Sep 17 00:00:00 2001
From: Joshua Peterson <joshuap@unity3d.com>
Date: Mon, 24 Jan 2022 09:15:38 -0500
Subject: [PATCH 030/161] Add missing handle function enter/return macros
 (#64061)

The mono_field_static_get_value method uses a handle, but did not set up
enter/exit macros properly, so this handle was leaked.

Some code in Unity calls this embedding API method pretty often, which
can lead to the mark stack overflowing in the GC code.
---
 src/mono/mono/metadata/object.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/mono/mono/metadata/object.c b/src/mono/mono/metadata/object.c
index 5863a967d544f0..9a39381533e5ae 100644
--- a/src/mono/mono/metadata/object.c
+++ b/src/mono/mono/metadata/object.c
@@ -3242,9 +3242,13 @@ mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value)
 {
 	MONO_REQ_GC_NEUTRAL_MODE;
 
+	HANDLE_FUNCTION_ENTER ();
+
 	ERROR_DECL (error);
 	mono_field_static_get_value_checked (vt, field, value, MONO_HANDLE_NEW (MonoString, NULL), error);
 	mono_error_cleanup (error);
+
+	HANDLE_FUNCTION_RETURN ();
 }
 
 /**

From 5a9e584d684d45ce67b6e9c9cf27114db20efd1b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Mon, 24 Jan 2022 23:28:06 +0900
Subject: [PATCH 031/161] Drop support for .NET 5 SDK (#64186)

We had to duplicate a lot of Microsoft.NET.ILLink.targets logic.
---
 .../Microsoft.NETCore.Native.Publish.targets  |  2 +-
 .../Microsoft.NETCore.Native.targets          | 41 -------------------
 2 files changed, 1 insertion(+), 42 deletions(-)

diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets
index 18258d4288b01f..ae6229a0a7afe6 100644
--- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets
+++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets
@@ -48,7 +48,7 @@
   <Target Name="_ComputeAssembliesToCompileToNative" DependsOnTargets="$(IlcDynamicBuildPropertyDependencies)">
 
     <!-- Fail with descriptive error message for common mistake. -->
-    <Error Condition="$([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '5.0.0'))" Text=".NET SDK 5+ is required for native compilation." />
+    <Error Condition="$([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '6.0.0'))" Text=".NET SDK 6+ is required for native compilation." />
     <Error Condition="'$(RuntimeIdentifier)' == ''"
       Text="RuntimeIdentifier is required for native compilation. Try running dotnet publish with the -r option value specified." />
     <Error Condition="'$(GeneratePackageOnBuild)' == 'true'" Text="GeneratePackageOnBuild is not supported for native compilation." />
diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
index 365afaa6ce4687..8fc0d8e6842e90 100644
--- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
+++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
@@ -40,8 +40,6 @@ The .NET Foundation licenses this file to you under the MIT license.
 
     <IlcGenerateStackTraceData Condition="$(IlcGenerateStackTraceData) == ''">true</IlcGenerateStackTraceData>
     <IlcScanReflection Condition="$(IlcScanReflection) == ''">true</IlcScanReflection>
-    <SuppressTrimAnalysisWarnings Condition="$(SuppressTrimAnalysisWarnings) == '' and $([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '6.0.0'))">true</SuppressTrimAnalysisWarnings>
-    <TrimmerDefaultAction Condition="$([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '6.0.0'))">copyused</TrimmerDefaultAction>
   </PropertyGroup>
 
   <!-- Set up default feature switches -->
@@ -132,13 +130,6 @@ The .NET Foundation licenses this file to you under the MIT license.
       <ManagedAssemblyToLink Remove="@(ManagedAssemblyToLink)" />
       <ManagedAssemblyToLink Include="@(DefaultFrameworkAssemblies);@(_ManagedResolvedAssembliesToPublish);@(ManagedBinary)" />
     </ItemGroup>
-    <ItemGroup Condition="$([MSBuild]::VersionLessThan('$(TargetFrameworkVersion)', '6.0'))">
-      <ManagedAssemblyToLink Remove="@(ManagedAssemblyToLink)" />
-      <ManagedAssemblyToLink Include="@(DefaultFrameworkAssemblies)">
-        <IsTrimmable>true</IsTrimmable>
-      </ManagedAssemblyToLink>
-      <ManagedAssemblyToLink Include="@(_ManagedResolvedAssembliesToPublish);@(ManagedBinary)" />
-    </ItemGroup>
   </Target>
 
   <!-- The properties below need to be defined only after we've found the correct runtime package reference -->
@@ -200,35 +191,6 @@ The .NET Foundation licenses this file to you under the MIT license.
       Outputs="%(ManagedBinary.IlcRspFile)"
       DependsOnTargets="$(IlcCompileDependsOn)">
 
-    <!-- Set up default properties that have their defaults in the 6.0 SDK (Can be dropped once we drop 5.0 support) -->
-    <PropertyGroup Condition="$([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '6.0.0'))">
-      <TrimmerSingleWarn Condition="'$(TrimmerSingleWarn)' == ''">true</TrimmerSingleWarn>
-    </PropertyGroup>
-
-    <!-- Set up single warn trimming like in the 6.0 SDK (Can be dropped once we drop 5.0 support) -->
-    <ItemGroup Condition="$([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '6.0.0'))">
-      <!-- Don't collapse to a single warning for the intermediate assembly.
-           This just sets metadata on the items in ManagedAssemblyToLink that came from IntermediateAssembly. -->
-      <!-- Find ManagedAssemblyToLink _except_ IntermediateAssembly -->
-      <__SingleWarnIntermediateAssembly Include="@(ManagedAssemblyToLink)" />
-      <__SingleWarnIntermediateAssembly Remove="@(IntermediateAssembly)" />
-      <!-- Subtract these from ManagedAssemblyToLink, to get the intersection. -->
-      <_SingleWarnIntermediateAssembly Include="@(ManagedAssemblyToLink)" />
-      <_SingleWarnIntermediateAssembly Remove="@(__SingleWarnIntermediateAssembly)" />
-      <!-- Set metadata on the intersection. -->
-      <_SingleWarnIntermediateAssembly>
-        <TrimmerSingleWarn Condition=" '%(_SingleWarnIntermediateAssembly.TrimmerSingleWarn)' == '' ">false</TrimmerSingleWarn>
-      </_SingleWarnIntermediateAssembly>
-      <!-- Replace these items in ManagedAssemblyToLink. -->
-      <ManagedAssemblyToLink Remove="@(_SingleWarnIntermediateAssembly)" />
-      <ManagedAssemblyToLink Include="@(_SingleWarnIntermediateAssembly)" />
-
-      <!-- Don't collapse to a single warning for project references -->
-      <ManagedAssemblyToLink Condition=" '%(ManagedAssemblyToLink.ProjectReferenceOriginalItemSpec)' != '' ">
-        <TrimmerSingleWarn Condition=" '%(ManagedAssemblyToLink.TrimmerSingleWarn)' == '' ">false</TrimmerSingleWarn>
-      </ManagedAssemblyToLink>
-    </ItemGroup>
-
     <ItemGroup>
       <_IlcRootedAssemblies Include="@(TrimmerRootAssembly)" />
       <_IlcRootedAssemblies Include="@(ManagedAssemblyToLink)" Condition="%(ManagedAssemblyToLink.TrimMode) == 'copy'" />
@@ -287,9 +249,6 @@ The .NET Foundation licenses this file to you under the MIT license.
       <IlcArg Include="--feature:System.Linq.Expressions.CanCompileToIL=false" />
       <IlcArg Include="--feature:System.Linq.Expressions.CanEmitObjectArrayDelegate=false" />
       <IlcArg Include="--feature:System.Linq.Expressions.CanCreateArbitraryDelegates=false" />
-
-      <!-- 6.0 SDK introduces a way to control this through the CustomResourceTypesSupport property, defaulting to false when trimming -->
-      <IlcArg Condition="$([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '6.0.0')) and $(CustomResourceTypesSupport) != 'true'" Include="--feature:System.Resources.ResourceManager.AllowCustomResourceTypes=false" />
     </ItemGroup>
 
     <MakeDir Directories="$(NativeIntermediateOutputPath)" />

From 0ac0071e457434c73bdd119911d1094f6ccee544 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Mon, 24 Jan 2022 09:43:25 -0500
Subject: [PATCH 032/161] Implement IEquatable<T> on value types overriding
 Equals (and enable CA1066/1077) (#63690)

---
 eng/CodeAnalysis.src.globalconfig             |  4 +-
 .../System.Private.CoreLib.csproj             |  2 -
 .../Diagnostics/SymbolStore/SymAddressKind.cs | 49 ------------
 .../System/Diagnostics/SymbolStore/Token.cs   | 39 ----------
 .../src/System/Reflection/MdImport.cs         |  2 +
 .../src/System/RuntimeHandles.cs              |  2 +-
 .../src/System/ModuleHandle.cs                |  2 +-
 .../General/TypeUnifier.NativeFormat.cs       |  2 +
 .../Runtime/TypeInfos/RuntimeNamedTypeInfo.cs |  2 +
 .../NativeFormat/Generator/ReaderGen.cs       |  1 +
 .../NativeFormat/NativeFormatReaderGen.cs     |  1 +
 .../NativeFormat/NativeMetadataReader.cs      |  7 +-
 .../Common/TypeSystem/Common/LayoutInt.cs     |  2 +
 .../Unix/System.Native/Interop.IPAddress.cs   | 16 +++-
 .../src/ServiceLookup/ServiceCacheKey.cs      | 13 +++-
 ...crosoft.Extensions.Logging.Abstractions.cs |  2 +-
 .../src/EventId.cs                            |  3 +-
 .../ImmutableDictionary_2.HashBucket.cs       |  2 +
 .../ImmutableHashSet_1.HashBucket.cs          |  2 +
 .../ref/System.Collections.Specialized.cs     |  5 +-
 .../Collections/Specialized/BitVector32.cs    | 11 ++-
 .../tests/BitVector32Tests.cs                 | 15 ++++
 .../ref/System.ComponentModel.Composition.cs  |  3 +-
 .../ReflectionModel/LazyMemberInfo.cs         | 25 +++---
 .../System.ComponentModel.TypeConverter.cs    |  3 +-
 .../MemberRelationshipService.cs              | 50 +++++-------
 .../ComponentModel/InterlockedBitVector32.cs  |  6 +-
 .../ref/System.Data.Common.cs                 | 39 ++++++----
 .../src/System/Data/DataKey.cs                |  4 +-
 .../src/System/Data/SQLTypes/SQLBinary.cs     | 25 +++---
 .../src/System/Data/SQLTypes/SQLBoolean.cs    | 28 +++----
 .../src/System/Data/SQLTypes/SQLByte.cs       | 28 +++----
 .../src/System/Data/SQLTypes/SQLDateTime.cs   | 28 +++----
 .../src/System/Data/SQLTypes/SQLDecimal.cs    | 25 +++---
 .../src/System/Data/SQLTypes/SQLDouble.cs     | 28 +++----
 .../src/System/Data/SQLTypes/SQLGuid.cs       | 28 +++----
 .../src/System/Data/SQLTypes/SQLInt16.cs      | 28 +++----
 .../src/System/Data/SQLTypes/SQLInt32.cs      | 28 +++----
 .../src/System/Data/SQLTypes/SQLInt64.cs      | 28 +++----
 .../src/System/Data/SQLTypes/SQLMoney.cs      | 29 +++----
 .../src/System/Data/SQLTypes/SQLSingle.cs     | 28 +++----
 .../src/System/Data/SQLTypes/SQLString.cs     | 25 +++---
 .../src/System/Data/Selection.cs              | 14 ++--
 .../System/Data/SqlTypes/SqlBinaryTest.cs     |  3 +
 .../System/Data/SqlTypes/SqlBooleanTest.cs    |  4 +
 .../tests/System/Data/SqlTypes/SqlByteTest.cs |  3 +
 .../System/Data/SqlTypes/SqlDateTimeTest.cs   |  2 +
 .../System/Data/SqlTypes/SqlDecimalTest.cs    |  2 +
 .../System/Data/SqlTypes/SqlDoubleTest.cs     |  3 +
 .../tests/System/Data/SqlTypes/SqlGuidTest.cs |  3 +
 .../System/Data/SqlTypes/SqlInt16Test.cs      |  3 +
 .../System/Data/SqlTypes/SqlInt64Test.cs      |  3 +
 .../System/Data/SqlTypes/SqlMoneyTest.cs      |  2 +
 .../System/Data/SqlTypes/SqlSingleTest.cs     |  3 +
 .../System/Data/SqlTypes/SqlStringTest.cs     |  3 +
 ...stem.Diagnostics.PerformanceCounter.csproj |  3 +-
 ...agnostics.PerformanceCounter.netcoreapp.cs | 12 +++
 ...stem.Diagnostics.PerformanceCounter.csproj |  1 +
 .../src/System/Diagnostics/CounterSample.cs   |  2 +-
 .../ref/System.Diagnostics.StackTrace.cs      |  2 +-
 .../Diagnostics/SymbolStore/SymbolToken.cs    |  2 +-
 .../ref/System.Drawing.Common.netcoreapp.cs   |  4 +
 .../src/System/Drawing/CharacterRange.cs      | 30 +++----
 .../src/System/Drawing/Printing/TriState.cs   | 78 +++++++------------
 .../tests/CharacterRangeTests.cs              |  1 +
 .../src/System/IO/Packaging/PackUriHelper.cs  |  2 +
 .../Expressions/Interpreter/LocalVariables.cs | 23 ++----
 .../ref/System.Net.Sockets.cs                 |  3 +-
 .../System/Net/Sockets/IPPacketInformation.cs | 48 ++++--------
 .../IPPacketInformationTest.cs                |  7 ++
 .../src/System/ArraySegment.cs                | 10 ++-
 .../Diagnostics/Tracing/EventDescriptor.cs    |  2 +-
 .../src/System/HashCode.cs                    |  2 +
 .../src/System/IntPtr.cs                      |  2 +
 .../src/System/Nullable.cs                    |  2 +
 .../CustomAttributeNamedArgument.cs           | 17 ++--
 .../CustomAttributeTypedArgument.cs           | 11 ++-
 .../InteropServices/ArrayWithOffset.cs        |  4 +-
 .../Runtime/InteropServices/GCHandle.cs       |  9 ++-
 .../Runtime/Serialization/StreamingContext.cs |  2 +
 .../src/System/Threading/CancellationToken.cs |  2 +-
 .../System/Threading/LowLevelLifoSemaphore.cs |  9 ++-
 .../PortableThreadPool.ThreadCounts.cs        |  5 +-
 .../PortableThreadPool.WorkerTracking.cs      | 11 ++-
 .../src/System/TimeZoneInfo.AdjustmentRule.cs |  6 ++
 .../src/System/UIntPtr.cs                     |  2 +
 .../System/Xml/BinaryXml/XmlBinaryReader.cs   | 49 ++++--------
 .../src/System/Xml/Xsl/Pair.cs                | 43 ++++------
 .../src/System/Xml/Xsl/XmlQueryCardinality.cs |  2 +-
 .../System/Runtime/Caching/CacheExpires.cs    | 55 +++----------
 .../src/System/Runtime/Caching/CacheUsage.cs  | 62 +++------------
 .../ref/System.Runtime.InteropServices.cs     |  2 +-
 .../Runtime/InteropServices/GCHandleTests.cs  |  1 +
 .../System.Runtime/ref/System.Runtime.cs      | 18 +++--
 ...stomAttribute_Named_Typed_ArgumentTests.cs | 22 ++++++
 ...iceProcess.ServiceController.netcoreapp.cs |  3 +
 ...em.ServiceProcess.ServiceController.csproj |  2 +
 .../SessionChangeDescription.cs               | 39 ++++------
 .../src/Internal/Synthesis/EngineSiteSapi.cs  | 38 ++++-----
 .../System.Text.Rune.netstandard20.cs         |  2 +-
 .../Symbolic/SymbolicMatch.cs                 | 12 ++-
 .../Symbolic/SymbolicRegexInfo.cs             |  6 +-
 .../System.Threading/ref/System.Threading.cs  |  2 +-
 .../src/System/Threading/LockCookie.cs        | 37 +++------
 .../ref/System.Transactions.Local.cs          |  5 +-
 .../System/Transactions/TransactionOptions.cs |  7 +-
 .../src/Mono/RuntimeHandles.cs                |  6 +-
 .../src/System/ModuleHandle.cs                |  2 +-
 .../src/System/Nullable.Mono.cs               |  2 +
 .../BrowserDebugProxy/DevToolsHelper.cs       | 12 ++-
 .../WasmAppBuilder/PInvokeTableGenerator.cs   |  2 +
 111 files changed, 650 insertions(+), 813 deletions(-)
 delete mode 100644 src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs
 delete mode 100644 src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/Token.cs
 create mode 100644 src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.netcoreapp.cs

diff --git a/eng/CodeAnalysis.src.globalconfig b/eng/CodeAnalysis.src.globalconfig
index 0fc9bf8e5a7eeb..e5ae41903b5a76 100644
--- a/eng/CodeAnalysis.src.globalconfig
+++ b/eng/CodeAnalysis.src.globalconfig
@@ -152,10 +152,10 @@ dotnet_diagnostic.CA1064.severity = none
 dotnet_diagnostic.CA1065.severity = none
 
 # CA1066: Implement IEquatable when overriding Object.Equals
-dotnet_diagnostic.CA1066.severity = none
+dotnet_diagnostic.CA1066.severity = warning
 
 # CA1067: Override Object.Equals(object) when implementing IEquatable<T>
-dotnet_diagnostic.CA1067.severity = none
+dotnet_diagnostic.CA1067.severity = warning
 
 # CA1068: CancellationToken parameters must come last
 dotnet_diagnostic.CA1068.severity = none
diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj
index e1230d59401d86..3d21bffd3d24f8 100644
--- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj
+++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj
@@ -140,8 +140,6 @@
     <Compile Include="$(BclSourcesRoot)\System\Diagnostics\StackFrame.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Diagnostics\StackFrameHelper.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Diagnostics\StackTrace.CoreCLR.cs" />
-    <Compile Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\SymAddressKind.cs" />
-    <Compile Include="$(BclSourcesRoot)\System\Diagnostics\SymbolStore\Token.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Enum.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Environment.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Exception.CoreCLR.cs" />
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs
deleted file mode 100644
index dc2a0a05708c16..00000000000000
--- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/SymAddressKind.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-/*============================================================
-**
-**
-**
-** Represents address Kinds used with local variables, parameters, and
-** fields.
-**
-**
-===========================================================*/
-// Only statics, does not need to be marked with the serializable attribute
-
-namespace System.Diagnostics.SymbolStore
-{
-    internal enum SymAddressKind
-    {
-        // ILOffset: addr1 = IL local var or param index.
-        ILOffset = 1,
-
-        // NativeRVA: addr1 = RVA into module.
-        NativeRVA = 2,
-
-        // NativeRegister: addr1 = register the var is stored in.
-        NativeRegister = 3,
-
-        // NativeRegisterRelative: addr1 = register, addr2 = offset.
-        NativeRegisterRelative = 4,
-
-        // NativeOffset: addr1 = offset from start of parent.
-        NativeOffset = 5,
-
-        // NativeRegisterRegister: addr1 = reg low, addr2 = reg high.
-        NativeRegisterRegister = 6,
-
-        // NativeRegisterStack: addr1 = reg low, addr2 = reg stk, addr3 = offset.
-        NativeRegisterStack = 7,
-
-        // NativeStackRegister: addr1 = reg stk, addr2 = offset, addr3 = reg high.
-        NativeStackRegister = 8,
-
-        // BitField: addr1 = field start, addr = field length.
-        BitField = 9,
-
-        // NativeSectionOffset: addr1 = section, addr = offset
-        NativeSectionOffset = 10,
-    }
-}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/Token.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/Token.cs
deleted file mode 100644
index fbd9f7e4bc1ae9..00000000000000
--- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/SymbolStore/Token.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-/*============================================================
-**
-**
-** Small value class used by the SymbolStore package for passing
-** around metadata tokens.
-**
-===========================================================*/
-
-using System.Diagnostics.CodeAnalysis;
-
-namespace System.Diagnostics.SymbolStore
-{
-    internal struct SymbolToken
-    {
-        internal int m_token;
-
-        public SymbolToken(int val) { m_token = val; }
-
-        public int GetToken() { return m_token; }
-
-        public override int GetHashCode() { return m_token; }
-
-        public override bool Equals([NotNullWhen(true)] object? obj)
-        {
-            if (obj is SymbolToken)
-                return Equals((SymbolToken)obj);
-            else
-                return false;
-        }
-
-        public bool Equals(SymbolToken obj)
-        {
-            return obj.m_token == m_token;
-        }
-    }
-}
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs
index 9368fc25d340b8..cdc15dc8fb6e08 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs
@@ -194,7 +194,9 @@ public int this[int index]
         }
     }
 
+#pragma warning disable CA1066 // IEquatable<MetadataImport> interface implementation isn't used
     internal readonly struct MetadataImport
+#pragma warning restore CA1067
     {
         private readonly IntPtr m_metadataImport2;
         private readonly object? m_keepalive;
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
index 977d73e5c3b990..32a37b6d4219f1 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
@@ -1246,7 +1246,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)
         }
     }
 
-    public unsafe partial struct ModuleHandle
+    public unsafe partial struct ModuleHandle : IEquatable<ModuleHandle>
     {
         #region Public Static Members
         public static readonly ModuleHandle EmptyHandle;
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/ModuleHandle.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/ModuleHandle.cs
index 3714e7ce510fba..d1bb831f347729 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/ModuleHandle.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/ModuleHandle.cs
@@ -6,7 +6,7 @@
 
 namespace System
 {
-    public struct ModuleHandle
+    public struct ModuleHandle : IEquatable<ModuleHandle>
     {
         public static readonly ModuleHandle EmptyHandle;
 
diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/TypeUnifier.NativeFormat.cs b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/TypeUnifier.NativeFormat.cs
index b44cf57cdff6dc..fe06816cf93e3e 100644
--- a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/TypeUnifier.NativeFormat.cs
+++ b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/TypeUnifier.NativeFormat.cs
@@ -34,6 +34,8 @@
 //   - The TypeUnifier extension class provides a more friendly interface to the rest of the codebase.
 //
 
+#pragma warning disable CA1067 // override Equals because it implements IEquatable<T>
+
 namespace System.Reflection.Runtime.General
 {
     internal static partial class TypeUnifier
diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeInfos/RuntimeNamedTypeInfo.cs b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeInfos/RuntimeNamedTypeInfo.cs
index 209a91e0cb1028..fdbcf0b53685d3 100644
--- a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeInfos/RuntimeNamedTypeInfo.cs
+++ b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeInfos/RuntimeNamedTypeInfo.cs
@@ -10,6 +10,8 @@
 
 using Internal.Reflection.Tracing;
 
+#pragma warning disable CA1067 // override Equals because it implements IEquatable<T>
+
 namespace System.Reflection.Runtime.TypeInfos
 {
     //
diff --git a/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/Generator/ReaderGen.cs b/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/Generator/ReaderGen.cs
index 55b09b37b3431e..aa1a796bfaa0f1 100644
--- a/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/Generator/ReaderGen.cs
+++ b/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/Generator/ReaderGen.cs
@@ -20,6 +20,7 @@ public void EmitSource()
         WriteLine("#pragma warning disable 649");
         WriteLine("#pragma warning disable 169");
         WriteLine("#pragma warning disable 282 // There is no defined ordering between fields in multiple declarations of partial class or struct");
+        WriteLine("#pragma warning disable CA1066 // IEquatable<T> implementations aren't used");
         WriteLine("#pragma warning disable IDE0059");
         WriteLine();
 
diff --git a/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeFormatReaderGen.cs b/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeFormatReaderGen.cs
index 1d92be56771488..bbc23ec8784848 100644
--- a/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeFormatReaderGen.cs
+++ b/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeFormatReaderGen.cs
@@ -6,6 +6,7 @@
 #pragma warning disable 649
 #pragma warning disable 169
 #pragma warning disable 282 // There is no defined ordering between fields in multiple declarations of partial class or struct
+#pragma warning disable CA1066 // IEquatable<T> implementations aren't used
 #pragma warning disable IDE0059
 
 using System;
diff --git a/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeMetadataReader.cs b/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeMetadataReader.cs
index 8eba905400e423..5b7921f972f97a 100644
--- a/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeMetadataReader.cs
+++ b/src/coreclr/tools/Common/Internal/Metadata/NativeFormat/NativeMetadataReader.cs
@@ -1,12 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-
 #pragma warning disable 169
-
-// There is no defined ordering between fields in multiple declarations of partial class or struct
-#pragma warning disable 282
-
+#pragma warning disable 282 // There is no defined ordering between fields in multiple declarations of partial class or struct
+#pragma warning disable CA1066 // IEquatable<T> implementations aren't used
 
 using System;
 using System.IO;
diff --git a/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs b/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs
index 2ec3883af9f08b..c794377bf19712 100644
--- a/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs
@@ -12,7 +12,9 @@ namespace Internal.TypeSystem
     /// type system do not have a known size. This type is used to make such sizes viral through the type layout
     /// computations)
     /// </summary>
+#pragma warning disable CA1066 // IEquatable<T> implementation wouldn't be used
     public struct LayoutInt
+#pragma warning restore CA1066
     {
         private int _value;
 
diff --git a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.IPAddress.cs b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.IPAddress.cs
index 567f97df901ce7..4bbd79987510bd 100644
--- a/src/libraries/Common/src/Interop/Unix/System.Native/Interop.IPAddress.cs
+++ b/src/libraries/Common/src/Interop/Unix/System.Native/Interop.IPAddress.cs
@@ -2,9 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
-using System.Text;
 
 internal static partial class Interop
 {
@@ -33,6 +32,19 @@ public bool IsIPv6
             private  uint _isIPv6;                             // Non-zero if this is an IPv6 address; zero for IPv4.
             internal uint ScopeId;                             // Scope ID (IPv6 only)
 
+            public override unsafe int GetHashCode()
+            {
+                HashCode h = default;
+                fixed (byte* ptr = Address)
+                {
+                    h.AddBytes(new ReadOnlySpan<byte>(ptr, IsIPv6 ? IPv6AddressBytes : IPv4AddressBytes));
+                }
+                return h.ToHashCode();
+            }
+
+            public override bool Equals([NotNullWhen(true)] object? obj) =>
+                obj is IPAddress other && Equals(other);
+
             public bool Equals(IPAddress other)
             {
                 int addressByteCount;
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceCacheKey.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceCacheKey.cs
index 8f812ae45e6a86..737c23d7f4445a 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceCacheKey.cs
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceCacheKey.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
 {
@@ -33,10 +34,14 @@ public ServiceCacheKey(Type? type, int slot)
             Slot = slot;
         }
 
-        public bool Equals(ServiceCacheKey other)
-        {
-            return Type == other.Type && Slot == other.Slot;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(ServiceCacheKey other) =>
+            Type == other.Type && Slot == other.Slot;
+
+        public override bool Equals([NotNullWhen(true)] object? obj) =>
+            obj is ServiceCacheKey other && Equals(other);
 
         public override int GetHashCode()
         {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
index 1404880a972882..33e79ca09252e4 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
@@ -6,7 +6,7 @@
 
 namespace Microsoft.Extensions.Logging
 {
-    public readonly partial struct EventId
+    public readonly partial struct EventId : System.IEquatable<Microsoft.Extensions.Logging.EventId>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs
index 972fb1ec0488ce..1cb4775b275b97 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.Extensions.Logging
@@ -8,7 +9,7 @@ namespace Microsoft.Extensions.Logging
     /// <summary>
     /// Identifies a logging event. The primary identifier is the "Id" property, with the "Name" property providing a short description of this type of event.
     /// </summary>
-    public readonly struct EventId
+    public readonly struct EventId : IEquatable<EventId>
     {
         /// <summary>
         /// Implicitly creates an EventId from the given <see cref="int"/>.
diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.HashBucket.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.HashBucket.cs
index aa8d7636cfbca0..2562372c666b4a 100644
--- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.HashBucket.cs
+++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.HashBucket.cs
@@ -15,7 +15,9 @@ public partial class ImmutableDictionary<TKey, TValue>
         /// <summary>
         /// Contains all the key/values in the collection that hash to the same value.
         /// </summary>
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
         internal readonly struct HashBucket : IEnumerable<KeyValuePair<TKey, TValue>>
+#pragma warning restore CA1066
         {
             /// <summary>
             /// One of the values in this bucket.
diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucket.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucket.cs
index 82fd48fbc62e5f..04ca794da7808e 100644
--- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucket.cs
+++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucket.cs
@@ -30,7 +30,9 @@ internal enum OperationResult
         /// <summary>
         /// Contains all the keys in the collection that hash to the same value.
         /// </summary>
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
         internal readonly struct HashBucket
+#pragma warning restore CA1066
         {
             /// <summary>
             /// One of the values in this bucket.
diff --git a/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs b/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs
index 1864717141ca47..00fc77efe910c2 100644
--- a/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs
+++ b/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs
@@ -6,7 +6,7 @@
 
 namespace System.Collections.Specialized
 {
-    public partial struct BitVector32
+    public partial struct BitVector32 : System.IEquatable<System.Collections.Specialized.BitVector32>
     {
         private int _dummyPrimitive;
         public BitVector32(System.Collections.Specialized.BitVector32 value) { throw null; }
@@ -18,11 +18,12 @@ public partial struct BitVector32
         public static int CreateMask(int previous) { throw null; }
         public static System.Collections.Specialized.BitVector32.Section CreateSection(short maxValue) { throw null; }
         public static System.Collections.Specialized.BitVector32.Section CreateSection(short maxValue, System.Collections.Specialized.BitVector32.Section previous) { throw null; }
+        public bool Equals(System.Collections.Specialized.BitVector32 other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? o) { throw null; }
         public override int GetHashCode() { throw null; }
         public override string ToString() { throw null; }
         public static string ToString(System.Collections.Specialized.BitVector32 value) { throw null; }
-        public readonly partial struct Section
+        public readonly partial struct Section : System.IEquatable<System.Collections.Specialized.BitVector32.Section>
         {
             private readonly int _dummyPrimitive;
             public short Mask { get { throw null; } }
diff --git a/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/BitVector32.cs b/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/BitVector32.cs
index ce4ba761ab7aff..60a2580cfb6fd0 100644
--- a/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/BitVector32.cs
+++ b/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/BitVector32.cs
@@ -10,7 +10,7 @@ namespace System.Collections.Specialized
     ///    <para>Provides a simple light bit vector with easy integer or Boolean access to
     ///       a 32 bit storage.</para>
     /// </devdoc>
-    public struct BitVector32
+    public struct BitVector32 : IEquatable<BitVector32>
     {
         private uint _data;
 
@@ -151,7 +151,12 @@ private static Section CreateSectionHelper(short maxValue, short priorMask, shor
             return new Section(mask, offset);
         }
 
-        public override bool Equals([NotNullWhen(true)] object? o) => o is BitVector32 other && _data == other._data;
+        public override bool Equals([NotNullWhen(true)] object? o) => o is BitVector32 other && Equals(other);
+
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(BitVector32 other) => _data == other._data;
 
         public override int GetHashCode() => _data.GetHashCode();
 
@@ -182,7 +187,7 @@ public override string ToString()
         ///    <para>
         ///       Represents an section of the vector that can contain a integer number.</para>
         /// </devdoc>
-        public readonly struct Section
+        public readonly struct Section : IEquatable<Section>
         {
             private readonly short _mask;
             private readonly short _offset;
diff --git a/src/libraries/System.Collections.Specialized/tests/BitVector32Tests.cs b/src/libraries/System.Collections.Specialized/tests/BitVector32Tests.cs
index 61734a09b741f1..69453b6c574d5a 100644
--- a/src/libraries/System.Collections.Specialized/tests/BitVector32Tests.cs
+++ b/src/libraries/System.Collections.Specialized/tests/BitVector32Tests.cs
@@ -518,17 +518,32 @@ public static void EqualsTest()
             Assert.True(new BitVector32(0).Equals(original));
             Assert.True(original.Equals(new BitVector32(0)));
 
+            Assert.True(original.Equals((object)original));
+            Assert.True(new BitVector32().Equals((object)original));
+            Assert.True(original.Equals((object)new BitVector32()));
+            Assert.True(new BitVector32(0).Equals((object)original));
+            Assert.True(original.Equals((object)new BitVector32(0)));
+
             BitVector32 other = new BitVector32(int.MaxValue / 2 - 1);
             Assert.True(other.Equals(other));
             Assert.True(new BitVector32(int.MaxValue / 2 - 1).Equals(other));
             Assert.True(other.Equals(new BitVector32(int.MaxValue / 2 - 1)));
 
+            Assert.True(other.Equals((object)other));
+            Assert.True(new BitVector32(int.MaxValue / 2 - 1).Equals((object)other));
+            Assert.True(other.Equals((object)new BitVector32(int.MaxValue / 2 - 1)));
+
             Assert.False(other.Equals(original));
             Assert.False(original.Equals(other));
             Assert.False(other.Equals(null));
             Assert.False(original.Equals(null));
             Assert.False(other.Equals(int.MaxValue / 2 - 1));
             Assert.False(original.Equals(0));
+
+            Assert.False(other.Equals((object)original));
+            Assert.False(original.Equals((object)other));
+            Assert.False(other.Equals(int.MaxValue / 2 - 1));
+            Assert.False(original.Equals(0));
         }
 
         [Fact]
diff --git a/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.cs b/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.cs
index f55f6b216d37f9..60accaee91e879 100644
--- a/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.cs
+++ b/src/libraries/System.ComponentModel.Composition/ref/System.ComponentModel.Composition.cs
@@ -608,7 +608,7 @@ public ImportDefinition(System.Linq.Expressions.Expression<System.Func<System.Co
 }
 namespace System.ComponentModel.Composition.ReflectionModel
 {
-    public partial struct LazyMemberInfo
+    public partial struct LazyMemberInfo : System.IEquatable<System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo>
     {
         private object _dummy;
         private int _dummyPrimitive;
@@ -616,6 +616,7 @@ public partial struct LazyMemberInfo
         public LazyMemberInfo(System.Reflection.MemberTypes memberType, System.Func<System.Reflection.MemberInfo[]> accessorsCreator) { throw null; }
         public LazyMemberInfo(System.Reflection.MemberTypes memberType, params System.Reflection.MemberInfo[] accessors) { throw null; }
         public System.Reflection.MemberTypes MemberType { get { throw null; } }
+        public bool Equals(System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo other) { throw null; }
         public override bool Equals(object? obj) { throw null; }
         public System.Reflection.MemberInfo[] GetAccessors() { throw null; }
         public override int GetHashCode() { throw null; }
diff --git a/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/LazyMemberInfo.cs b/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/LazyMemberInfo.cs
index 480e339c4080f5..02d1f811e71b71 100644
--- a/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/LazyMemberInfo.cs
+++ b/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/LazyMemberInfo.cs
@@ -8,7 +8,7 @@
 
 namespace System.ComponentModel.Composition.ReflectionModel
 {
-    public struct LazyMemberInfo
+    public struct LazyMemberInfo : IEquatable<LazyMemberInfo>
     {
         private readonly MemberTypes _memberType;
         private MemberInfo?[]? _accessors;
@@ -106,31 +106,32 @@ public override int GetHashCode()
             throw new Exception(SR.Diagnostic_InternalExceptionMessage);
         }
 
-        public override bool Equals(object? obj)
-        {
-            if (obj is not LazyMemberInfo that)
-            {
-                return false;
-            }
+        public override bool Equals(object? obj) =>
+            obj is LazyMemberInfo other && Equals(other);
 
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(LazyMemberInfo other)
+        {
             // Different member types mean different members
-            if (_memberType != that._memberType)
+            if (_memberType != other._memberType)
             {
                 return false;
             }
 
             // if any of the lazy memebers create accessors in a delay-loaded fashion, we simply compare the creators
-            if ((_accessorsCreator != null) || (that._accessorsCreator != null))
+            if ((_accessorsCreator != null) || (other._accessorsCreator != null))
             {
-                return object.Equals(_accessorsCreator, that._accessorsCreator);
+                return object.Equals(_accessorsCreator, other._accessorsCreator);
             }
 
             // we are dealing with explicitly passed accessors in both cases
-            if (_accessors == null || that._accessors == null)
+            if (_accessors == null || other._accessors == null)
             {
                 throw new Exception(SR.Diagnostic_InternalExceptionMessage);
             }
-            return _accessors.SequenceEqual(that._accessors);
+            return _accessors.SequenceEqual(other._accessors);
         }
 
         public static bool operator ==(LazyMemberInfo left, LazyMemberInfo right)
diff --git a/src/libraries/System.ComponentModel.TypeConverter/ref/System.ComponentModel.TypeConverter.cs b/src/libraries/System.ComponentModel.TypeConverter/ref/System.ComponentModel.TypeConverter.cs
index 510fffca714069..8fe3c9a37f8217 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/ref/System.ComponentModel.TypeConverter.cs
+++ b/src/libraries/System.ComponentModel.TypeConverter/ref/System.ComponentModel.TypeConverter.cs
@@ -2164,7 +2164,7 @@ public InstanceDescriptor(System.Reflection.MemberInfo? member, System.Collectio
         public object? Invoke() { throw null; }
     }
     [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public readonly partial struct MemberRelationship
+    public readonly partial struct MemberRelationship : System.IEquatable<System.ComponentModel.Design.Serialization.MemberRelationship>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
@@ -2173,6 +2173,7 @@ public readonly partial struct MemberRelationship
         public bool IsEmpty { get { throw null; } }
         public System.ComponentModel.MemberDescriptor Member { get { throw null; } }
         public object? Owner { get { throw null; } }
+        public bool Equals(System.ComponentModel.Design.Serialization.MemberRelationship other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; }
         public override int GetHashCode() { throw null; }
         public static bool operator ==(System.ComponentModel.Design.Serialization.MemberRelationship left, System.ComponentModel.Design.Serialization.MemberRelationship right) { throw null; }
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/Serialization/MemberRelationshipService.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/Serialization/MemberRelationshipService.cs
index 6691792d7fcfe3..090fa91accbf7c 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/Serialization/MemberRelationshipService.cs
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/Serialization/MemberRelationshipService.cs
@@ -153,7 +153,7 @@ private static void ThrowRelationshipNotSupported(MemberRelationship source, Mem
         /// <summary>
         /// Used as storage in our relationship table
         /// </summary>
-        private struct RelationshipEntry
+        private struct RelationshipEntry : IEquatable<RelationshipEntry>
         {
             internal WeakReference _owner;
             internal MemberDescriptor _member;
@@ -169,20 +169,19 @@ internal RelationshipEntry(MemberRelationship rel)
             public override bool Equals([NotNullWhen(true)] object? o)
             {
                 Debug.Assert(o is RelationshipEntry, "This is only called indirectly from a dictionary only containing RelationshipEntry structs.");
-                return this == (RelationshipEntry)o;
+                return Equals((RelationshipEntry)o);
             }
 
-            public static bool operator ==(RelationshipEntry re1, RelationshipEntry re2)
+            public bool Equals(RelationshipEntry other)
             {
-                object? owner1 = (re1._owner.IsAlive ? re1._owner.Target : null);
-                object? owner2 = (re2._owner.IsAlive ? re2._owner.Target : null);
-                return owner1 == owner2 && re1._member.Equals(re2._member);
+                object? owner1 = (_owner.IsAlive ? _owner.Target : null);
+                object? owner2 = (other._owner.IsAlive ? other._owner.Target : null);
+                return owner1 == owner2 && _member.Equals(other._member);
             }
 
-            public static bool operator !=(RelationshipEntry re1, RelationshipEntry re2)
-            {
-                return !(re1 == re2);
-            }
+            public static bool operator ==(RelationshipEntry re1, RelationshipEntry re2) => re1.Equals(re2);
+
+            public static bool operator !=(RelationshipEntry re1, RelationshipEntry re2) => !re1.Equals(re2);
 
             public override int GetHashCode() => _hashCode;
         }
@@ -191,7 +190,7 @@ public override bool Equals([NotNullWhen(true)] object? o)
     /// <summary>
     /// This class represents a single relationship between an object and a member.
     /// </summary>
-    public readonly struct MemberRelationship
+    public readonly struct MemberRelationship : IEquatable<MemberRelationship>
     {
         public static readonly MemberRelationship Empty;
 
@@ -222,37 +221,26 @@ public MemberRelationship(object owner, MemberDescriptor member)
         /// <summary>
         /// Infrastructure support to make this a first class struct
         /// </summary>
-        public override bool Equals([NotNullWhen(true)] object? obj)
-        {
-            return obj is MemberRelationship rel && rel.Owner == Owner && rel.Member == Member;
-        }
+        public override bool Equals([NotNullWhen(true)] object? obj) => obj is MemberRelationship rel && Equals(rel);
 
         /// <summary>
         /// Infrastructure support to make this a first class struct
         /// </summary>
-        public override int GetHashCode()
-        {
-            if (Owner == null)
-            {
-                return base.GetHashCode();
-            }
+        public bool Equals(MemberRelationship other) => other.Owner == Owner && other.Member == Member;
 
-            return Owner.GetHashCode() ^ Member.GetHashCode();
-        }
         /// <summary>
         /// Infrastructure support to make this a first class struct
         /// </summary>
-        public static bool operator ==(MemberRelationship left, MemberRelationship right)
-        {
-            return left.Owner == right.Owner && left.Member == right.Member;
-        }
+        public override int GetHashCode() => Owner is null ? base.GetHashCode() : Owner.GetHashCode() ^ Member.GetHashCode();
 
         /// <summary>
         /// Infrastructure support to make this a first class struct
         /// </summary>
-        public static bool operator !=(MemberRelationship left, MemberRelationship right)
-        {
-            return !(left == right);
-        }
+        public static bool operator ==(MemberRelationship left, MemberRelationship right) => left.Equals(right);
+
+        /// <summary>
+        /// Infrastructure support to make this a first class struct
+        /// </summary>
+        public static bool operator !=(MemberRelationship left, MemberRelationship right) => !left.Equals(right);
     }
 }
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/InterlockedBitVector32.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/InterlockedBitVector32.cs
index 2190f32299fbb4..7aa25ce5bdf631 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/InterlockedBitVector32.cs
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/InterlockedBitVector32.cs
@@ -11,7 +11,7 @@ namespace System.ComponentModel
     /// Provides a subset of the <see cref="System.Collections.Specialized.BitVector32"/> surface area, using volatile
     /// operations for reads and interlocked operations for writes.
     /// </summary>
-    internal struct InterlockedBitVector32
+    internal struct InterlockedBitVector32 : IEquatable<InterlockedBitVector32>
     {
         private int _data;
 
@@ -44,7 +44,9 @@ public static int CreateMask(int previous)
             return previous == 0 ? 1 : previous << 1;
         }
 
-        public override bool Equals([NotNullWhen(true)] object? o) => o is InterlockedBitVector32 vector && _data == vector._data;
+        public override bool Equals([NotNullWhen(true)] object? o) => o is InterlockedBitVector32 other && Equals(other);
+
+        public bool Equals(InterlockedBitVector32 other) => _data == other._data;
 
         public override int GetHashCode() => base.GetHashCode();
     }
diff --git a/src/libraries/System.Data.Common/ref/System.Data.Common.cs b/src/libraries/System.Data.Common/ref/System.Data.Common.cs
index 569f83d8ac7776..5e664573d5ea6c 100644
--- a/src/libraries/System.Data.Common/ref/System.Data.Common.cs
+++ b/src/libraries/System.Data.Common/ref/System.Data.Common.cs
@@ -2737,7 +2737,7 @@ public SqlAlreadyFilledException(string? message) { }
         public SqlAlreadyFilledException(string? message, System.Exception? e) { }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlBinary : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlBinary : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlBinary>
     {
         private object _dummy;
         private int _dummyPrimitive;
@@ -2752,6 +2752,7 @@ public partial struct SqlBinary : System.Data.SqlTypes.INullable, System.ICompar
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlBinary Concat(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlBinary other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -2777,7 +2778,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public override string ToString() { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlBoolean : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlBoolean : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlBoolean>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlBoolean False;
@@ -2796,6 +2797,7 @@ public partial struct SqlBoolean : System.Data.SqlTypes.INullable, System.ICompa
         public int CompareTo(System.Data.SqlTypes.SqlBoolean value) { throw null; }
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlBoolean other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -2847,7 +2849,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public static System.Data.SqlTypes.SqlBoolean Xor(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlByte : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlByte : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlByte>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlByte MaxValue;
@@ -2864,6 +2866,7 @@ public partial struct SqlByte : System.Data.SqlTypes.INullable, System.IComparab
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlByte Divide(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlByte other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -2987,7 +2990,7 @@ public enum SqlCompareOptions
         BinarySort = 32768,
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlDateTime : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlDateTime : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlDateTime>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlDateTime MaxValue;
@@ -3010,6 +3013,7 @@ public partial struct SqlDateTime : System.Data.SqlTypes.INullable, System.IComp
         public int CompareTo(System.Data.SqlTypes.SqlDateTime value) { throw null; }
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlDateTime other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3038,7 +3042,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public override string ToString() { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlDecimal : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlDecimal : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlDecimal>
     {
         private int _dummyPrimitive;
         public static readonly byte MaxPrecision;
@@ -3068,6 +3072,7 @@ public partial struct SqlDecimal : System.Data.SqlTypes.INullable, System.ICompa
         public static System.Data.SqlTypes.SqlDecimal ConvertToPrecScale(System.Data.SqlTypes.SqlDecimal n, int precision, int scale) { throw null; }
         public static System.Data.SqlTypes.SqlDecimal Divide(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlDecimal other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public static System.Data.SqlTypes.SqlDecimal Floor(System.Data.SqlTypes.SqlDecimal n) { throw null; }
         public override int GetHashCode() { throw null; }
@@ -3124,7 +3129,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public static System.Data.SqlTypes.SqlDecimal Truncate(System.Data.SqlTypes.SqlDecimal n, int position) { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlDouble : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlDouble : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlDouble>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlDouble MaxValue;
@@ -3139,6 +3144,7 @@ public partial struct SqlDouble : System.Data.SqlTypes.INullable, System.ICompar
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlDouble Divide(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlDouble other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3187,7 +3193,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public override string ToString() { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlGuid : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlGuid : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlGuid>
     {
         private object _dummy;
         private int _dummyPrimitive;
@@ -3201,6 +3207,7 @@ public partial struct SqlGuid : System.Data.SqlTypes.INullable, System.IComparab
         public int CompareTo(System.Data.SqlTypes.SqlGuid value) { throw null; }
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlGuid other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3229,7 +3236,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public override string ToString() { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlInt16 : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlInt16 : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlInt16>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlInt16 MaxValue;
@@ -3246,6 +3253,7 @@ public partial struct SqlInt16 : System.Data.SqlTypes.INullable, System.ICompara
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlInt16 Divide(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlInt16 other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3303,7 +3311,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public static System.Data.SqlTypes.SqlInt16 Xor(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlInt32 : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlInt32 : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlInt32>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlInt32 MaxValue;
@@ -3320,6 +3328,7 @@ public partial struct SqlInt32 : System.Data.SqlTypes.INullable, System.ICompara
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlInt32 Divide(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlInt32 other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3377,7 +3386,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public static System.Data.SqlTypes.SqlInt32 Xor(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlInt64 : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlInt64 : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlInt64>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlInt64 MaxValue;
@@ -3394,6 +3403,7 @@ public partial struct SqlInt64 : System.Data.SqlTypes.INullable, System.ICompara
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlInt64 Divide(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlInt64 other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3451,7 +3461,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public static System.Data.SqlTypes.SqlInt64 Xor(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlMoney : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlMoney : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlMoney>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlMoney MaxValue;
@@ -3469,6 +3479,7 @@ public partial struct SqlMoney : System.Data.SqlTypes.INullable, System.ICompara
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlMoney Divide(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlMoney other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3535,7 +3546,7 @@ public SqlNullValueException(string? message) { }
         public SqlNullValueException(string? message, System.Exception? e) { }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlSingle : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlSingle : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlSingle>
     {
         private int _dummyPrimitive;
         public static readonly System.Data.SqlTypes.SqlSingle MaxValue;
@@ -3551,6 +3562,7 @@ public partial struct SqlSingle : System.Data.SqlTypes.INullable, System.ICompar
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlSingle Divide(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlSingle other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public static System.Xml.XmlQualifiedName GetXsdType(System.Xml.Schema.XmlSchemaSet schemaSet) { throw null; }
@@ -3599,7 +3611,7 @@ void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter wri
         public override string ToString() { throw null; }
     }
     [System.Xml.Serialization.XmlSchemaProviderAttribute("GetXsdType")]
-    public partial struct SqlString : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable
+    public partial struct SqlString : System.Data.SqlTypes.INullable, System.IComparable, System.Xml.Serialization.IXmlSerializable, System.IEquatable<System.Data.SqlTypes.SqlString>
     {
         private object _dummy;
         private int _dummyPrimitive;
@@ -3630,6 +3642,7 @@ public partial struct SqlString : System.Data.SqlTypes.INullable, System.ICompar
         public int CompareTo(object? value) { throw null; }
         public static System.Data.SqlTypes.SqlString Concat(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
         public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { throw null; }
+        public bool Equals(System.Data.SqlTypes.SqlString other) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? value) { throw null; }
         public override int GetHashCode() { throw null; }
         public byte[]? GetNonUnicodeBytes() { throw null; }
diff --git a/src/libraries/System.Data.Common/src/System/Data/DataKey.cs b/src/libraries/System.Data.Common/src/System/Data/DataKey.cs
index 379035bb75d6b3..7f1a15f75f51b7 100644
--- a/src/libraries/System.Data.Common/src/System/Data/DataKey.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/DataKey.cs
@@ -5,7 +5,7 @@
 
 namespace System.Data
 {
-    internal readonly struct DataKey
+    internal readonly struct DataKey : IEquatable<DataKey>
     {
         private const int maxColumns = 32;
 
@@ -154,7 +154,7 @@ public override bool Equals(object? value)
             return Equals((DataKey)value);
         }
 
-        internal bool Equals(DataKey value)
+        public bool Equals(DataKey value)
         {
             //check to see if this.columns && key2's columns are equal...
             DataColumn[] column1 = _columns;
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBinary.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBinary.cs
index a757be446e73a7..f6a45dbba5f2cb 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBinary.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBinary.cs
@@ -12,7 +12,7 @@
 namespace System.Data.SqlTypes
 {
     [XmlSchemaProvider("GetXsdType")]
-    public struct SqlBinary : INullable, IComparable, IXmlSerializable
+    public struct SqlBinary : INullable, IComparable, IXmlSerializable, IEquatable<SqlBinary>
     {
         // NOTE: If any instance fields change, update SqlTypeWorkarounds type in System.Data.SqlClient.
         private byte[]? _value;
@@ -362,20 +362,15 @@ public int CompareTo(SqlBinary value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlBinary))
-            {
-                return false;
-            }
-
-            SqlBinary i = (SqlBinary)value;
-
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlBinary other && Equals(other);
+
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlBinary other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // Hash a byte array.
         // Trailing zeroes/spaces would affect the hash value, so caller needs to
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBoolean.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBoolean.cs
index 1efff18021e52b..d7b723f9f05f01 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBoolean.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLBoolean.cs
@@ -18,7 +18,7 @@ namespace System.Data.SqlTypes
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlBoolean : INullable, IComparable, IXmlSerializable
+    public struct SqlBoolean : INullable, IComparable, IXmlSerializable, IEquatable<SqlBoolean>
     {
         // m_value: 2 (true), 1 (false), 0 (unknown/Null)
         private byte m_value; // Do not rename (binary serialization)
@@ -465,26 +465,18 @@ public int CompareTo(SqlBoolean value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlBoolean))
-            {
-                return false;
-            }
-
-            SqlBoolean i = (SqlBoolean)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlBoolean other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlBoolean other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLByte.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLByte.cs
index f7c1cdde432260..3dc5548ffed7a3 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLByte.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLByte.cs
@@ -18,7 +18,7 @@ namespace System.Data.SqlTypes
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlByte : INullable, IComparable, IXmlSerializable
+    public struct SqlByte : INullable, IComparable, IXmlSerializable, IEquatable<SqlByte>
     {
         private bool m_fNotNull; // false if null. Do not rename (binary serialization)
         private byte m_value; // Do not rename (binary serialization)
@@ -474,26 +474,18 @@ public int CompareTo(SqlByte value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlByte))
-            {
-                return false;
-            }
-
-            SqlByte i = (SqlByte)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlByte other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlByte other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDateTime.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDateTime.cs
index 195ca26628ea40..1edd44bedf3388 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDateTime.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDateTime.cs
@@ -21,7 +21,7 @@ namespace System.Data.SqlTypes
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlDateTime : INullable, IComparable, IXmlSerializable
+    public struct SqlDateTime : INullable, IComparable, IXmlSerializable, IEquatable<SqlDateTime>
     {
         private bool m_fNotNull;    // false if null. Do not rename (binary serialization)
         private int m_day;      // Day from 1900/1/1, could be negative. Range: Jan 1 1753 - Dec 31 9999. Do not rename (binary serialization)
@@ -621,26 +621,18 @@ public int CompareTo(SqlDateTime value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlDateTime))
-            {
-                return false;
-            }
-
-            SqlDateTime i = (SqlDateTime)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlDateTime other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlDateTime other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDecimal.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDecimal.cs
index 784d50d2bb1cfc..336639fbf0e5b4 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDecimal.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDecimal.cs
@@ -18,7 +18,7 @@ namespace System.Data.SqlTypes
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
-    public struct SqlDecimal : INullable, IComparable, IXmlSerializable
+    public struct SqlDecimal : INullable, IComparable, IXmlSerializable, IEquatable<SqlDecimal>
     {
         // data in CSsNumeric in SQL Server
         // BYTE    m_cbLen;                // # of DWORDs + 1 (1 is for sign)
@@ -3278,20 +3278,15 @@ public int CompareTo(SqlDecimal value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlDecimal))
-            {
-                return false;
-            }
-
-            SqlDecimal i = (SqlDecimal)value;
-
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlDecimal other && Equals(other);
+
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlDecimal other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
         public override int GetHashCode()
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDouble.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDouble.cs
index 3f10f943124002..4cc9ac4e321e0e 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDouble.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLDouble.cs
@@ -19,7 +19,7 @@ namespace System.Data.SqlTypes
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlDouble : INullable, IComparable, IXmlSerializable
+    public struct SqlDouble : INullable, IComparable, IXmlSerializable, IEquatable<SqlDouble>
     {
         private bool m_fNotNull; // false if null. Do not rename (binary serialization)
         private double m_value; // Do not rename (binary serialization)
@@ -390,26 +390,18 @@ public int CompareTo(SqlDouble value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlDouble))
-            {
-                return false;
-            }
-
-            SqlDouble i = (SqlDouble)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlDouble other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlDouble other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLGuid.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLGuid.cs
index 8e3c58dff3dadf..2742c25d53b53a 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLGuid.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLGuid.cs
@@ -16,7 +16,7 @@ namespace System.Data.SqlTypes
     [Serializable]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlGuid : INullable, IComparable, IXmlSerializable
+    public struct SqlGuid : INullable, IComparable, IXmlSerializable, IEquatable<SqlGuid>
     {
         private const int SizeOfGuid = 16;
 
@@ -281,26 +281,18 @@ public int CompareTo(SqlGuid value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlGuid))
-            {
-                return false;
-            }
-
-            SqlGuid i = (SqlGuid)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlGuid other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlGuid other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt16.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt16.cs
index 5833a009385612..d3879a06cf91b2 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt16.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt16.cs
@@ -17,7 +17,7 @@ namespace System.Data.SqlTypes
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlInt16 : INullable, IComparable, IXmlSerializable
+    public struct SqlInt16 : INullable, IComparable, IXmlSerializable, IEquatable<SqlInt16>
     {
         private bool m_fNotNull; // false if null. Do not rename (binary serialization)
         private short m_value; // Do not rename (binary serialization)
@@ -475,26 +475,18 @@ public int CompareTo(SqlInt16 value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlInt16))
-            {
-                return false;
-            }
-
-            SqlInt16 i = (SqlInt16)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlInt16 other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlInt16 other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt32.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt32.cs
index 271d6509e71f58..8ce08e74e4403e 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt32.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt32.cs
@@ -17,7 +17,7 @@ namespace System.Data.SqlTypes
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlInt32 : INullable, IComparable, IXmlSerializable
+    public struct SqlInt32 : INullable, IComparable, IXmlSerializable, IEquatable<SqlInt32>
     {
         private bool m_fNotNull; // false if null, the default ctor (plain 0) will make it Null. Do not rename (binary serialization)
         private int m_value; // Do not rename (binary serialization)
@@ -490,26 +490,18 @@ public int CompareTo(SqlInt32 value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlInt32))
-            {
-                return false;
-            }
-
-            SqlInt32 i = (SqlInt32)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlInt32 other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlInt32 other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt64.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt64.cs
index b7f33674ce03a8..393945b0303957 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt64.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLInt64.cs
@@ -18,7 +18,7 @@ namespace System.Data.SqlTypes
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlInt64 : INullable, IComparable, IXmlSerializable
+    public struct SqlInt64 : INullable, IComparable, IXmlSerializable, IEquatable<SqlInt64>
     {
         private bool m_fNotNull; // false if null. Do not rename (binary serialization)
         private long m_value; // Do not rename (binary serialization)
@@ -549,26 +549,18 @@ public int CompareTo(SqlInt64 value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlInt64))
-            {
-                return false;
-            }
-
-            SqlInt64 i = (SqlInt64)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlInt64 other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlInt64 other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLMoney.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLMoney.cs
index 5431c8737d4aff..64c0d168631c86 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLMoney.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLMoney.cs
@@ -21,7 +21,7 @@ namespace System.Data.SqlTypes
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
-    public struct SqlMoney : INullable, IComparable, IXmlSerializable
+    public struct SqlMoney : INullable, IComparable, IXmlSerializable, IEquatable<SqlMoney>
     {
         // NOTE: If any instance fields change, update SqlTypeWorkarounds type in System.Data.SqlClient.
         private bool _fNotNull; // false if null
@@ -539,27 +539,20 @@ public int CompareTo(SqlMoney value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlMoney))
-            {
-                return false;
-            }
-
-            SqlMoney i = (SqlMoney)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlMoney other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlMoney other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
+        public override int GetHashCode() =>
             // Don't use Value property, because Value will convert to Decimal, which is not necessary.
-            return IsNull ? 0 : _value.GetHashCode();
-        }
+            IsNull ? 0 : _value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLSingle.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLSingle.cs
index 59f29dcc89cbca..5fa7562824e13d 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLSingle.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLSingle.cs
@@ -17,7 +17,7 @@ namespace System.Data.SqlTypes
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
-    public struct SqlSingle : INullable, IComparable, IXmlSerializable
+    public struct SqlSingle : INullable, IComparable, IXmlSerializable, IEquatable<SqlSingle>
     {
         private bool _fNotNull; // false if null
         private float _value;
@@ -400,26 +400,18 @@ public int CompareTo(SqlSingle value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlSingle))
-            {
-                return false;
-            }
-
-            SqlSingle i = (SqlSingle)value;
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlSingle other && Equals(other);
 
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlSingle other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
-        public override int GetHashCode()
-        {
-            return IsNull ? 0 : Value.GetHashCode();
-        }
+        public override int GetHashCode() => IsNull ? 0 : Value.GetHashCode();
 
         XmlSchema? IXmlSerializable.GetSchema() { return null; }
 
diff --git a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLString.cs b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLString.cs
index cac4122feba684..0c22570d2462d2 100644
--- a/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLString.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/SQLTypes/SQLString.cs
@@ -34,7 +34,7 @@ public enum SqlCompareOptions
     [StructLayout(LayoutKind.Sequential)]
     [XmlSchemaProvider("GetXsdType")]
     [System.Runtime.CompilerServices.TypeForwardedFrom("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
-    public struct SqlString : INullable, IComparable, IXmlSerializable
+    public struct SqlString : INullable, IComparable, IXmlSerializable, IEquatable<SqlString>
     {
         private string? m_value; // Do not rename (binary serialization)
         private CompareInfo? m_cmpInfo; // Do not rename (binary serialization)
@@ -871,20 +871,15 @@ public int CompareTo(SqlString value)
         }
 
         // Compares this instance with a specified object
-        public override bool Equals([NotNullWhen(true)] object? value)
-        {
-            if (!(value is SqlString))
-            {
-                return false;
-            }
-
-            SqlString i = (SqlString)value;
-
-            if (i.IsNull || IsNull)
-                return (i.IsNull && IsNull);
-            else
-                return (this == i).Value;
-        }
+        public override bool Equals([NotNullWhen(true)] object? value) =>
+            value is SqlString other && Equals(other);
+
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(SqlString other) =>
+            other.IsNull || IsNull ? other.IsNull && IsNull :
+            (this == other).Value;
 
         // For hashing purpose
         public override int GetHashCode()
diff --git a/src/libraries/System.Data.Common/src/System/Data/Selection.cs b/src/libraries/System.Data.Common/src/System/Data/Selection.cs
index 21a6d951393c19..fd76acfda7c36f 100644
--- a/src/libraries/System.Data.Common/src/System/Data/Selection.cs
+++ b/src/libraries/System.Data.Common/src/System/Data/Selection.cs
@@ -9,7 +9,7 @@
 
 namespace System.Data
 {
-    internal readonly struct IndexField
+    internal readonly struct IndexField : IEquatable<IndexField>
     {
         public readonly DataColumn Column;
         public readonly bool IsDescending; // false = Asc; true = Desc what is default value for this?
@@ -22,15 +22,15 @@ internal IndexField(DataColumn column, bool isDescending)
             IsDescending = isDescending;
         }
 
-        public static bool operator ==(IndexField if1, IndexField if2) =>
-            if1.Column == if2.Column && if1.IsDescending == if2.IsDescending;
+        public static bool operator ==(IndexField if1, IndexField if2) => if1.Equals(if2);
 
-        public static bool operator !=(IndexField if1, IndexField if2) => !(if1 == if2);
+        public static bool operator !=(IndexField if1, IndexField if2) => !if1.Equals(if2);
 
         // must override Equals if == operator is defined
-        public override bool Equals([NotNullWhen(true)] object? obj) => obj is IndexField ?
-            this == (IndexField)obj :
-            false;
+        public override bool Equals([NotNullWhen(true)] object? obj) =>
+            obj is IndexField other && Equals(other);
+
+        public bool Equals(IndexField other) => Column == other.Column && IsDescending == other.IsDescending;
 
         // must override GetHashCode if Equals is redefined
         public override int GetHashCode() =>
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBinaryTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBinaryTest.cs
index 6a631b392bea90..8655d3feea0030 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBinaryTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBinaryTest.cs
@@ -122,8 +122,11 @@ public void ComparisonMethods()
 
             // Equals
             Assert.False(_test1.Equals(_test2));
+            Assert.False(_test1.Equals((object)_test2));
             Assert.False(_test3.Equals(_test2));
+            Assert.False(_test3.Equals((object)_test2));
             Assert.True(_test3.Equals(_test1));
+            Assert.True(_test3.Equals((object)_test1));
 
             // NotEquals
             Assert.True(SqlBinary.NotEquals(_test1, _test2).Value);
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBooleanTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBooleanTest.cs
index 4da63a4bcdcf83..b52f671dad2d4b 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBooleanTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlBooleanTest.cs
@@ -242,10 +242,14 @@ public void EqualsTest()
             SqlBoolean sqlFalse2 = new SqlBoolean(false);
 
             Assert.True(_sqlTrue.Equals(sqlTrue2));
+            Assert.True(_sqlTrue.Equals((object)sqlTrue2));
             Assert.True(_sqlFalse.Equals(sqlFalse2));
+            Assert.True(_sqlFalse.Equals((object)sqlFalse2));
 
             Assert.False(_sqlTrue.Equals(_sqlFalse));
+            Assert.False(_sqlTrue.Equals((object)_sqlFalse));
             Assert.False(_sqlFalse.Equals(_sqlTrue));
+            Assert.False(_sqlFalse.Equals((object)_sqlTrue));
 
             Assert.False(_sqlTrue.Equals(SqlBoolean.Null));
             Assert.False(_sqlFalse.Equals(SqlBoolean.Null));
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlByteTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlByteTest.cs
index 2ae5976e9f1a9e..9af75f4f46997b 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlByteTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlByteTest.cs
@@ -155,9 +155,12 @@ public void EqualsMethod()
             SqlByte testByte180II = new SqlByte(180);
 
             Assert.False(testByte0.Equals(testByte158));
+            Assert.False(testByte0.Equals((object)testByte158));
             Assert.False(testByte158.Equals(testByte180));
+            Assert.False(testByte158.Equals((object)testByte180));
             Assert.False(testByte180.Equals(new SqlString("TEST")));
             Assert.True(testByte180.Equals(testByte180II));
+            Assert.True(testByte180.Equals((object)testByte180II));
         }
 
         [Fact]
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDateTimeTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDateTimeTest.cs
index 6d3287ed49b0fd..0c835ff00c5405 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDateTimeTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDateTimeTest.cs
@@ -175,8 +175,10 @@ public void CompareTo()
         public void EqualsMethods()
         {
             Assert.False(_test1.Equals(_test2));
+            Assert.False(_test1.Equals((object)_test2));
             Assert.False(_test2.Equals(new SqlString("TEST")));
             Assert.True(_test2.Equals(_test3));
+            Assert.True(_test2.Equals((object)_test3));
 
             // Static Equals()-method
             Assert.True(SqlDateTime.Equals(_test2, _test3).Value);
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDecimalTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDecimalTest.cs
index 6fd72ba4157aaf..b9807ebcc102e2 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDecimalTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDecimalTest.cs
@@ -225,8 +225,10 @@ public void CompareTo()
         public void EqualsMethods()
         {
             Assert.False(_test1.Equals(_test2));
+            Assert.False(_test1.Equals((object)_test2));
             Assert.False(_test2.Equals(new SqlString("TEST")));
             Assert.True(_test2.Equals(_test3));
+            Assert.True(_test2.Equals((object)_test3));
 
             // Static Equals()-method
             Assert.True(SqlDecimal.Equals(_test2, _test2).Value);
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDoubleTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDoubleTest.cs
index 4f0856e2ba2269..db913271dc0209 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDoubleTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlDoubleTest.cs
@@ -134,9 +134,12 @@ public void EqualsMethods()
             SqlDouble test22 = new SqlDouble(1.8e180);
 
             Assert.False(test0.Equals(test1));
+            Assert.False(test0.Equals((object)test1));
             Assert.False(test1.Equals(test2));
+            Assert.False(test1.Equals((object)test2));
             Assert.False(test2.Equals(new SqlString("TEST")));
             Assert.True(test2.Equals(test22));
+            Assert.True(test2.Equals((object)test22));
 
             // Static Equals()-method
             Assert.True(SqlDouble.Equals(test2, test22).Value);
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlGuidTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlGuidTest.cs
index 84dcb3a3f53730..4c21e38d07ef2a 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlGuidTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlGuidTest.cs
@@ -126,9 +126,12 @@ public void CompareTo()
         public void EqualsMethods()
         {
             Assert.False(_test1.Equals(_test2));
+            Assert.False(_test1.Equals((object)_test2));
             Assert.False(_test2.Equals(_test4));
+            Assert.False(_test2.Equals((object)_test4));
             Assert.False(_test2.Equals(new SqlString("TEST")));
             Assert.True(_test2.Equals(_test3));
+            Assert.True(_test2.Equals((object)_test3));
 
             // Static Equals()-method
             Assert.True(SqlGuid.Equals(_test2, _test3).Value);
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt16Test.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt16Test.cs
index 3c240d6d9ed0f1..7c00f4845884de 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt16Test.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt16Test.cs
@@ -157,9 +157,12 @@ public void EqualsMethod()
             SqlInt16 test180II = new SqlInt16(180);
 
             Assert.False(test0.Equals(test158));
+            Assert.False(test0.Equals((object)test158));
             Assert.False(test158.Equals(test180));
+            Assert.False(test158.Equals((object)test180));
             Assert.False(test180.Equals(new SqlString("TEST")));
             Assert.True(test180.Equals(test180II));
+            Assert.True(test180.Equals((object)test180II));
         }
 
         [Fact]
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt64Test.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt64Test.cs
index 601b6a8bdb1bcc..ed466fb50b277f 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt64Test.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlInt64Test.cs
@@ -159,9 +159,12 @@ public void EqualsMethod()
             SqlInt64 test180II = new SqlInt64(180);
 
             Assert.False(test0.Equals(test158));
+            Assert.False(test0.Equals((object)test158));
             Assert.False(test158.Equals(test180));
+            Assert.False(test158.Equals((object)test180));
             Assert.False(test180.Equals(new SqlString("TEST")));
             Assert.True(test180.Equals(test180II));
+            Assert.True(test180.Equals((object)test180II));
         }
 
         [Fact]
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlMoneyTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlMoneyTest.cs
index 726302190b3884..db99ba4de6691c 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlMoneyTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlMoneyTest.cs
@@ -131,7 +131,9 @@ public void CompareTo()
         public void EqualsMethods()
         {
             Assert.False(_test1.Equals(_test2));
+            Assert.False(_test1.Equals((object)_test2));
             Assert.True(_test2.Equals(_test3));
+            Assert.True(_test2.Equals((object)_test3));
             Assert.False(SqlMoney.Equals(_test1, _test2).Value);
             Assert.True(SqlMoney.Equals(_test3, _test2).Value);
         }
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlSingleTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlSingleTest.cs
index 2c92e08226e490..3ff6c803aaef60 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlSingleTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlSingleTest.cs
@@ -132,9 +132,12 @@ public void EqualsMethods()
             SqlSingle test22 = new SqlSingle(1.8e32);
 
             Assert.False(test0.Equals(test1));
+            Assert.False(test0.Equals((object)test1));
             Assert.False(test1.Equals(test2));
+            Assert.False(test1.Equals((object)test2));
             Assert.False(test2.Equals(new SqlString("TEST")));
             Assert.True(test2.Equals(test22));
+            Assert.True(test2.Equals((object)test22));
 
             // Static Equals()-method
             Assert.True(SqlSingle.Equals(test2, test22).Value);
diff --git a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlStringTest.cs b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlStringTest.cs
index 86a4b1683c4c92..56f8fa51b06ca2 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlStringTest.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/SqlTypes/SqlStringTest.cs
@@ -262,9 +262,12 @@ public void CompareTo()
         public void EqualsMethods()
         {
             Assert.False(_test1.Equals(_test2));
+            Assert.False(_test1.Equals((object)_test2));
             Assert.False(_test3.Equals(_test1));
+            Assert.False(_test3.Equals((object)_test1));
             Assert.False(_test2.Equals(new SqlString("TEST")));
             Assert.True(_test2.Equals(_test3));
+            Assert.True(_test2.Equals((object)_test3));
 
             // Static Equals()-method
             Assert.True(SqlString.Equals(_test2, _test3).Value);
diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.csproj b/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.csproj
index 9851685566186c..220c3e850b5f1f 100644
--- a/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.csproj
+++ b/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.csproj
@@ -6,6 +6,7 @@
   <ItemGroup>
     <Compile Include="System.Diagnostics.PerformanceCounter.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETFramework'" />
     <Compile Include="System.Diagnostics.PerformanceCounter.netframework.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'" />
+    <Compile Include="System.Diagnostics.PerformanceCounter.netcoreapp.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
     <ProjectReference Include="$(LibrariesProjectRoot)System.Collections.NonGeneric\ref\System.Collections.NonGeneric.csproj" />
@@ -18,4 +19,4 @@
     <Reference Include="System.Runtime" />
     <Reference Include="System.Runtime.InteropServices" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.netcoreapp.cs b/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.netcoreapp.cs
new file mode 100644
index 00000000000000..b33f32066185b1
--- /dev/null
+++ b/src/libraries/System.Diagnostics.PerformanceCounter/ref/System.Diagnostics.PerformanceCounter.netcoreapp.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+
+namespace System.Diagnostics
+{
+    public readonly partial struct CounterSample : System.IEquatable<System.Diagnostics.CounterSample>
+    {
+    }
+}
diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/src/System.Diagnostics.PerformanceCounter.csproj b/src/libraries/System.Diagnostics.PerformanceCounter/src/System.Diagnostics.PerformanceCounter.csproj
index 28133feec83ed6..5ebf58e40c57e6 100644
--- a/src/libraries/System.Diagnostics.PerformanceCounter/src/System.Diagnostics.PerformanceCounter.csproj
+++ b/src/libraries/System.Diagnostics.PerformanceCounter/src/System.Diagnostics.PerformanceCounter.csproj
@@ -3,6 +3,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent);$(NetCoreAppMinimum)-windows;$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
     <NoWarn>$(NoWarn);CA1847</NoWarn>
+    <NoWarn Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">$(NoWarn);CA1066</NoWarn>
     <Nullable>annotations</Nullable>
     <IsPackable>true</IsPackable>
     <PackageDescription>Provides the System.Diagnostics.PerformanceCounter class, which allows access to Windows performance counters.
diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/CounterSample.cs b/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/CounterSample.cs
index c89df23ed9aac6..315ec5a87ccb47 100644
--- a/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/CounterSample.cs
+++ b/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/CounterSample.cs
@@ -6,7 +6,7 @@ namespace System.Diagnostics
     /// <summary>
     ///     A struct holding the raw data for a performance counter.
     /// </summary>
-    public readonly struct CounterSample
+    public readonly struct CounterSample : IEquatable<CounterSample>
     {
         private readonly long _rawValue;
         private readonly long _baseValue;
diff --git a/src/libraries/System.Diagnostics.StackTrace/ref/System.Diagnostics.StackTrace.cs b/src/libraries/System.Diagnostics.StackTrace/ref/System.Diagnostics.StackTrace.cs
index 0efbf90bb1da10..60e755ecf790c4 100644
--- a/src/libraries/System.Diagnostics.StackTrace/ref/System.Diagnostics.StackTrace.cs
+++ b/src/libraries/System.Diagnostics.StackTrace/ref/System.Diagnostics.StackTrace.cs
@@ -170,7 +170,7 @@ public enum SymAddressKind
         BitField = 9,
         NativeSectionOffset = 10,
     }
-    public readonly partial struct SymbolToken
+    public readonly partial struct SymbolToken : System.IEquatable<System.Diagnostics.SymbolStore.SymbolToken>
     {
         private readonly int _dummyPrimitive;
         public SymbolToken(int val) { throw null; }
diff --git a/src/libraries/System.Diagnostics.StackTrace/src/System/Diagnostics/SymbolStore/SymbolToken.cs b/src/libraries/System.Diagnostics.StackTrace/src/System/Diagnostics/SymbolStore/SymbolToken.cs
index b6a894f144fc90..8b27f618770fb7 100644
--- a/src/libraries/System.Diagnostics.StackTrace/src/System/Diagnostics/SymbolStore/SymbolToken.cs
+++ b/src/libraries/System.Diagnostics.StackTrace/src/System/Diagnostics/SymbolStore/SymbolToken.cs
@@ -5,7 +5,7 @@
 
 namespace System.Diagnostics.SymbolStore
 {
-    public readonly struct SymbolToken
+    public readonly struct SymbolToken : IEquatable<SymbolToken>
     {
         private readonly int _token;
 
diff --git a/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.netcoreapp.cs b/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.netcoreapp.cs
index f9d987de24d1c1..1514ee19e8c331 100644
--- a/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.netcoreapp.cs
+++ b/src/libraries/System.Drawing.Common/ref/System.Drawing.Common.netcoreapp.cs
@@ -6,6 +6,10 @@
 
 namespace System.Drawing
 {
+    public partial struct CharacterRange : System.IEquatable<System.Drawing.CharacterRange>
+    {
+        public bool Equals(System.Drawing.CharacterRange other) { throw null; }
+    }
     public sealed partial class Graphics
     {
         public void DrawRectangle(System.Drawing.Pen pen, System.Drawing.RectangleF rect) { }
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/CharacterRange.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/CharacterRange.cs
index 157533b84283c6..a0dccdc4b28765 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/CharacterRange.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/CharacterRange.cs
@@ -7,51 +7,43 @@
 namespace System.Drawing
 {
     [StructLayout(LayoutKind.Sequential)]
-    public struct CharacterRange
+    public struct CharacterRange : IEquatable<CharacterRange>
     {
         private int _first;
         private int _length;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref='CharacterRange'/> class with the specified coordinates.
-        /// </summary>
+        /// <summary>Initializes a new instance of the <see cref='CharacterRange'/> class with the specified coordinates.</summary>
         public CharacterRange(int First, int Length)
         {
             _first = First;
             _length = Length;
         }
 
-        /// <summary>
-        /// Gets the First character position of this <see cref='CharacterRange'/>.
-        /// </summary>
+        /// <summary>Gets the First character position of this <see cref='CharacterRange'/>.</summary>
         public int First
         {
             get => _first;
             set => _first = value;
         }
 
-        /// <summary>
-        /// Gets the Length of this <see cref='CharacterRange'/>.
-        /// </summary>
+        /// <summary>Gets the Length of this <see cref='CharacterRange'/>.</summary>
         public int Length
         {
             get => _length;
             set => _length = value;
         }
 
-        public override bool Equals([NotNullWhen(true)] object? obj)
-        {
-            if (!(obj is CharacterRange cr))
-            {
-                return false;
-            }
+        public override bool Equals([NotNullWhen(true)] object? obj) =>
+            obj is CharacterRange other && Equals(other);
 
-            return First == cr.First && Length == cr.Length;
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(CharacterRange other) => First == other.First && Length == other.Length;
 
         public static bool operator ==(CharacterRange cr1, CharacterRange cr2) => cr1.Equals(cr2);
 
-        public static bool operator !=(CharacterRange cr1, CharacterRange cr2) => !(cr1 == cr2);
+        public static bool operator !=(CharacterRange cr1, CharacterRange cr2) => !cr1.Equals(cr2);
 
         public override int GetHashCode() => HashCode.Combine(First, Length);
     }
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/TriState.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/TriState.cs
index 665a642a3e4f36..bb7b163d1ce958 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/TriState.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/Printing/TriState.cs
@@ -1,9 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
 namespace System.Drawing.Printing
 {
-    internal readonly partial struct TriState
+    internal readonly partial struct TriState : IEquatable<TriState>
     {
         private readonly byte _value; // 0 is "default", not false
 
@@ -11,73 +14,46 @@ internal readonly partial struct TriState
         public static readonly TriState False = new TriState(1);
         public static readonly TriState True = new TriState(2);
 
-        private TriState(byte value)
-        {
-            _value = value;
-        }
+        private TriState(byte value) => _value = value;
 
-        public bool IsDefault
-        {
-            get { return this == Default; }
-        }
+        public bool IsDefault => this == Default;
 
-        public bool IsFalse
-        {
-            get { return this == False; }
-        }
+        public bool IsFalse => this == False;
 
-        public bool IsNotDefault
-        {
-            get { return this != Default; }
-        }
+        public bool IsNotDefault => this != Default;
 
-        public bool IsTrue
-        {
-            get { return this == True; }
-        }
+        public bool IsTrue => this == True;
 
-        public static bool operator ==(TriState left, TriState right)
-        {
-            return left._value == right._value;
-        }
+        public static bool operator ==(TriState left, TriState right) => left.Equals(right);
 
-        public static bool operator !=(TriState left, TriState right)
-        {
-            return !(left == right);
-        }
+        public static bool operator !=(TriState left, TriState right) => !left.Equals(right);
 
-        public override bool Equals(object? o)
+        public override bool Equals([NotNullWhen(true)] object? o)
         {
-            TriState state = (TriState)o!;
-            return _value == state._value;
+            Debug.Assert(o is TriState);
+            return Equals((TriState)o);
         }
 
-        public override int GetHashCode()
-        {
-            return _value;
-        }
+        public bool Equals(TriState other) => _value == other._value;
 
-        public static implicit operator TriState(bool value)
-        {
-            return (value) ? True : False;
-        }
+        public override int GetHashCode() => _value;
+
+        public static implicit operator TriState(bool value) => value ? True : False;
 
         public static explicit operator bool(TriState value)
         {
             if (value.IsDefault)
+            {
                 throw new InvalidCastException(SR.TriStateCompareError);
-            else
-                return (value == TriState.True);
-        }
+            }
 
-        /// <summary>
-        /// Provides some interesting information about the TriState in String form.
-        /// </summary>
-        public override string ToString()
-        {
-            if (this == Default) return "Default";
-            else if (this == False) return "False";
-            else return "True";
+            return (value == TriState.True);
         }
+
+        /// <summary>Provides some interesting information about the TriState in String form.</summary>
+        public override string ToString() =>
+            this == Default ? "Default" :
+            this == False ? "False" :
+            "True";
     }
 }
diff --git a/src/libraries/System.Drawing.Common/tests/CharacterRangeTests.cs b/src/libraries/System.Drawing.Common/tests/CharacterRangeTests.cs
index 7147cb809be6bb..989ee85c093120 100644
--- a/src/libraries/System.Drawing.Common/tests/CharacterRangeTests.cs
+++ b/src/libraries/System.Drawing.Common/tests/CharacterRangeTests.cs
@@ -84,6 +84,7 @@ public void Equals_Invoke_ReturnsExpected(CharacterRange range, object obj, bool
             Assert.Equal(expected, range.Equals(obj));
             if (obj is CharacterRange otherRange)
             {
+                Assert.Equal(expected, range.Equals(otherRange));
                 Assert.Equal(expected, range == otherRange);
                 Assert.Equal(!expected, range != otherRange);
                 Assert.Equal(expected, range.GetHashCode().Equals(otherRange.GetHashCode()));
diff --git a/src/libraries/System.IO.Packaging/src/System/IO/Packaging/PackUriHelper.cs b/src/libraries/System.IO.Packaging/src/System/IO/Packaging/PackUriHelper.cs
index 15c89947da327f..5825a149f3315d 100644
--- a/src/libraries/System.IO.Packaging/src/System/IO/Packaging/PackUriHelper.cs
+++ b/src/libraries/System.IO.Packaging/src/System/IO/Packaging/PackUriHelper.cs
@@ -611,7 +611,9 @@ private static bool IsPartNameEmpty(string partName)
         /// to reduce the parsing and number of allocations for Strings and Uris
         /// we cache the results after parsing.
         /// </summary>
+ #pragma warning disable CA1067 // Override Equals because it implements IEquatable<T>; not overriding to avoid possible regressions in code that's working
         internal sealed class ValidatedPartUri : Uri, IComparable<ValidatedPartUri>, IEquatable<ValidatedPartUri>
+#pragma warning restore CA1067
         {
             //------------------------------------------------------
             //
diff --git a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LocalVariables.cs b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LocalVariables.cs
index d078d82a597f4e..f42254df42dd3e 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LocalVariables.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LocalVariables.cs
@@ -44,7 +44,7 @@ public override string ToString() =>
             string.Create(CultureInfo.InvariantCulture, $"{Index}: {(IsBoxed ? "boxed" : null)} {(InClosure ? "in closure" : null)}");
     }
 
-    internal readonly struct LocalDefinition
+    internal readonly struct LocalDefinition : IEquatable<LocalDefinition>
     {
         internal LocalDefinition(int localIndex, ParameterExpression parameter)
         {
@@ -53,27 +53,14 @@ internal LocalDefinition(int localIndex, ParameterExpression parameter)
         }
 
         public int Index { get; }
+
         public ParameterExpression Parameter { get; }
 
-        public override bool Equals([NotNullWhen(true)] object? obj)
-        {
-            if (obj is LocalDefinition)
-            {
-                LocalDefinition other = (LocalDefinition)obj;
-                return other.Index == Index && other.Parameter == Parameter;
-            }
+        public override bool Equals([NotNullWhen(true)] object? obj) => obj is LocalDefinition other && Equals(other);
 
-            return false;
-        }
+        public bool Equals(LocalDefinition other) => other.Index == Index && other.Parameter == Parameter;
 
-        public override int GetHashCode()
-        {
-            if (Parameter == null)
-            {
-                return 0;
-            }
-            return Parameter.GetHashCode() ^ Index.GetHashCode();
-        }
+        public override int GetHashCode() => Parameter is null ? 0 : Parameter.GetHashCode() ^ Index.GetHashCode();
     }
 
     internal sealed class LocalVariables
diff --git a/src/libraries/System.Net.Sockets/ref/System.Net.Sockets.cs b/src/libraries/System.Net.Sockets/ref/System.Net.Sockets.cs
index 212c063b3b3308..e813cca044ee04 100644
--- a/src/libraries/System.Net.Sockets/ref/System.Net.Sockets.cs
+++ b/src/libraries/System.Net.Sockets/ref/System.Net.Sockets.cs
@@ -74,13 +74,14 @@ public enum IOControlCode : long
         [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")]
         AddressListSort = (long)3355443225,
     }
-    public partial struct IPPacketInformation
+    public partial struct IPPacketInformation : System.IEquatable<System.Net.Sockets.IPPacketInformation>
     {
         private object _dummy;
         private int _dummyPrimitive;
         public System.Net.IPAddress Address { get { throw null; } }
         public int Interface { get { throw null; } }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhen(true)] object? comparand) { throw null; }
+        public bool Equals(System.Net.Sockets.IPPacketInformation other) { throw null; }
         public override int GetHashCode() { throw null; }
         public static bool operator ==(System.Net.Sockets.IPPacketInformation packetInformation1, System.Net.Sockets.IPPacketInformation packetInformation2) { throw null; }
         public static bool operator !=(System.Net.Sockets.IPPacketInformation packetInformation1, System.Net.Sockets.IPPacketInformation packetInformation2) { throw null; }
diff --git a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/IPPacketInformation.cs b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/IPPacketInformation.cs
index 06d4eca31750b0..b0597b626c4804 100644
--- a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/IPPacketInformation.cs
+++ b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/IPPacketInformation.cs
@@ -5,7 +5,7 @@
 
 namespace System.Net.Sockets
 {
-    public struct IPPacketInformation
+    public struct IPPacketInformation : IEquatable<IPPacketInformation>
     {
         private readonly IPAddress _address;
         private readonly int _networkInterface;
@@ -16,41 +16,27 @@ internal IPPacketInformation(IPAddress address, int networkInterface)
             _networkInterface = networkInterface;
         }
 
-        public IPAddress Address
-        {
-            get
-            {
-                return _address;
-            }
-        }
+        public IPAddress Address => _address;
 
-        public int Interface
-        {
-            get
-            {
-                return _networkInterface;
-            }
-        }
+        public int Interface => _networkInterface;
 
-        public static bool operator ==(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2)
-        {
-            return packetInformation1._networkInterface == packetInformation2._networkInterface &&
-                ((packetInformation1._address == null && packetInformation2._address == null) ||
-                (packetInformation1._address != null && packetInformation1._address.Equals(packetInformation2._address)));
-        }
+        public static bool operator ==(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2) =>
+            packetInformation1.Equals(packetInformation2);
 
-        public static bool operator !=(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2)
-        {
-            return !(packetInformation1 == packetInformation2);
-        }
+        public static bool operator !=(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2) =>
+            !packetInformation1.Equals(packetInformation2);
 
         public override bool Equals([NotNullWhen(true)] object? comparand) =>
-            comparand is IPPacketInformation other && this == other;
+            comparand is IPPacketInformation other && Equals(other);
 
-        public override int GetHashCode()
-        {
-            return unchecked(_networkInterface.GetHashCode() * (int)0xA5555529) +
-                (_address == null ? 0 : _address.GetHashCode());
-        }
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(IPPacketInformation other) =>
+            _networkInterface == other._networkInterface &&
+            (_address is null ? other._address is null : _address.Equals(other._address));
+
+        public override int GetHashCode() =>
+            unchecked(_networkInterface.GetHashCode() * (int)0xA5555529) + (_address?.GetHashCode() ?? 0);
     }
 }
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/IPPacketInformationTest.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/IPPacketInformationTest.cs
index 443924b66d2b44..19dbc7f470d007 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/IPPacketInformationTest.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/IPPacketInformationTest.cs
@@ -13,7 +13,10 @@ public class IPPacketInformationTest
         public void Equals_DefaultValues_Success()
         {
             Assert.Equal(default(IPPacketInformation), default(IPPacketInformation));
+
             Assert.True(default(IPPacketInformation) == default(IPPacketInformation));
+            Assert.True(default(IPPacketInformation).Equals(default(IPPacketInformation)));
+
             Assert.False(default(IPPacketInformation) != default(IPPacketInformation));
         }
 
@@ -31,10 +34,14 @@ public void Equals_NonDefaultValue_Success()
 
             Assert.Equal(packetInfo, packetInfoCopy);
             Assert.True(packetInfo == packetInfoCopy);
+            Assert.True(packetInfo.Equals(packetInfoCopy));
+            Assert.True(packetInfo.Equals((object)packetInfoCopy));
             Assert.False(packetInfo != packetInfoCopy);
 
             Assert.NotEqual(default, packetInfo);
             Assert.False(packetInfo == default(IPPacketInformation));
+            Assert.False(packetInfo.Equals(default(IPPacketInformation)));
+            Assert.False(packetInfo.Equals((object)default(IPPacketInformation)));
             Assert.True(packetInfo != default(IPPacketInformation));
 
             int ignored = packetInfo.Interface; // just make sure it doesn't throw, nothing else to verify
diff --git a/src/libraries/System.Private.CoreLib/src/System/ArraySegment.cs b/src/libraries/System.Private.CoreLib/src/System/ArraySegment.cs
index 06c31c4d6e0097..2d6c817b872686 100644
--- a/src/libraries/System.Private.CoreLib/src/System/ArraySegment.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/ArraySegment.cs
@@ -26,8 +26,16 @@ namespace System
     // (ie, users could assign a new value to the old location).
     [Serializable]
     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
+#pragma warning disable CA1066 // adding IEquatable<T> implementation could change semantics of code like that in xunit that queries for IEquatable vs enumerating contents
     public readonly struct ArraySegment<T> : IList<T>, IReadOnlyList<T>
+#pragma warning restore CA1066
     {
+        // ArraySegment<T> doesn't implement IEquatable<T>, even though it provides a strongly-typed
+        // Equals(T), as that results in different comparison semantics than comparing item-by-item
+        // the elements returned from its IEnumerable<T> implementation.  This then is a breaking change
+        // for usage like that in xunit's Assert.Equal, which will prioritize using an instance's IEquatable<T>
+        // over its IEnumerable<T>.
+
         // Do not replace the array allocation with Array.Empty. We don't want to have the overhead of
         // instantiating another generic type in addition to ArraySegment<T> for new type parameters.
 #pragma warning disable CA1825
@@ -120,7 +128,7 @@ public void CopyTo(ArraySegment<T> destination)
         }
 
         public override bool Equals([NotNullWhen(true)] object? obj) =>
-            obj is ArraySegment<T> && Equals((ArraySegment<T>)obj);
+            obj is ArraySegment<T> other && Equals(other);
 
         public bool Equals(ArraySegment<T> obj) =>
             obj._array == _array && obj._offset == _offset && obj._count == _count;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventDescriptor.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventDescriptor.cs
index c3994e613a3160..b1aaccd7f7f7c6 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventDescriptor.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventDescriptor.cs
@@ -15,7 +15,7 @@ namespace System.Diagnostics.Tracing
 #if ES_BUILD_STANDALONE
     [System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
 #endif
-    internal struct EventDescriptor
+    internal readonly struct EventDescriptor : IEquatable<EventDescriptor>
     {
         #region private
         [FieldOffset(0)]
diff --git a/src/libraries/System.Private.CoreLib/src/System/HashCode.cs b/src/libraries/System.Private.CoreLib/src/System/HashCode.cs
index d9735f05b44348..f40830e416d368 100644
--- a/src/libraries/System.Private.CoreLib/src/System/HashCode.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/HashCode.cs
@@ -47,6 +47,8 @@ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 using System.Runtime.InteropServices;
 using Internal.Runtime.CompilerServices;
 
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
+
 namespace System
 {
     // xxHash32 is used for the hash code.
diff --git a/src/libraries/System.Private.CoreLib/src/System/IntPtr.cs b/src/libraries/System.Private.CoreLib/src/System/IntPtr.cs
index 7fb1803d6f5ab0..355578395db40d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IntPtr.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IntPtr.cs
@@ -11,6 +11,8 @@
 using Internal.Runtime.CompilerServices;
 
 #pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
+
 #if TARGET_64BIT
 using nint_t = System.Int64;
 #else
diff --git a/src/libraries/System.Private.CoreLib/src/System/Nullable.cs b/src/libraries/System.Private.CoreLib/src/System/Nullable.cs
index 0fa9141483ee24..089f970057dc8a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Nullable.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Nullable.cs
@@ -4,6 +4,8 @@
 using System.Collections.Generic;
 using System.Runtime.Versioning;
 
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
+
 namespace System
 {
     // Because we have special type system support that says a boxed Nullable<T>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeNamedArgument.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeNamedArgument.cs
index 9699e14e5d1e53..b2baa777460a6b 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeNamedArgument.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeNamedArgument.cs
@@ -1,9 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
+
 namespace System.Reflection
 {
-    public readonly partial struct CustomAttributeNamedArgument
+    public readonly partial struct CustomAttributeNamedArgument : IEquatable<CustomAttributeNamedArgument>
     {
         public static bool operator ==(CustomAttributeNamedArgument left, CustomAttributeNamedArgument right) => left.Equals(right);
         public static bool operator !=(CustomAttributeNamedArgument left, CustomAttributeNamedArgument right) => !left.Equals(right);
@@ -46,10 +48,15 @@ public override int GetHashCode()
             return base.GetHashCode();
         }
 
-        public override bool Equals(object? obj)
-        {
-            return obj == (object)this;
-        }
+        public override bool Equals([NotNullWhen(true)] object? obj) =>
+            obj is CustomAttributeNamedArgument other && Equals(other);
+
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(CustomAttributeNamedArgument other) =>
+            _memberInfo == other._memberInfo &&
+            _value == other._value;
 
         internal Type ArgumentType =>
             _memberInfo is FieldInfo fi ?
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeTypedArgument.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeTypedArgument.cs
index 3198e9fd458027..b0e306af8f838e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeTypedArgument.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/CustomAttributeTypedArgument.cs
@@ -2,11 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
 namespace System.Reflection
 {
-    public readonly partial struct CustomAttributeTypedArgument
+    public readonly partial struct CustomAttributeTypedArgument : IEquatable<CustomAttributeTypedArgument>
     {
         public static bool operator ==(CustomAttributeTypedArgument left, CustomAttributeTypedArgument right) => left.Equals(right);
         public static bool operator !=(CustomAttributeTypedArgument left, CustomAttributeTypedArgument right) => !left.Equals(right);
@@ -86,7 +87,13 @@ internal string ToString(bool typed)
         }
 
         public override int GetHashCode() => base.GetHashCode();
-        public override bool Equals(object? obj) => obj == (object)this;
+
+        public override bool Equals([NotNullWhen(true)] object? obj) => obj is CustomAttributeTypedArgument cata && Equals(cata);
+
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(CustomAttributeTypedArgument other) => _value == other._value && _argumentType == other._argumentType;
 
         public Type ArgumentType => _argumentType;
         public object? Value => _value;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ArrayWithOffset.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ArrayWithOffset.cs
index 8a80faa9977b61..92d42d67955672 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ArrayWithOffset.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ArrayWithOffset.cs
@@ -6,7 +6,7 @@
 
 namespace System.Runtime.InteropServices
 {
-    public readonly struct ArrayWithOffset
+    public readonly struct ArrayWithOffset : IEquatable<ArrayWithOffset>
     {
         private readonly object? m_array;
         private readonly int m_offset;
@@ -52,7 +52,7 @@ public ArrayWithOffset(object? array, int offset)
 
         public override bool Equals([NotNullWhen(true)] object? obj)
         {
-            return obj is ArrayWithOffset && Equals((ArrayWithOffset)obj);
+            return obj is ArrayWithOffset awo && Equals(awo);
         }
 
         public bool Equals(ArrayWithOffset obj)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.cs
index 579633db55cafc..a1c849b48c71b1 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.cs
@@ -23,7 +23,7 @@ namespace System.Runtime.InteropServices
     /// Pinned - same as Normal, but allows the address of the actual object to be taken.
     /// </remarks>
     [StructLayout(LayoutKind.Sequential)]
-    public partial struct GCHandle
+    public partial struct GCHandle : IEquatable<GCHandle>
     {
         // The actual integer handle value that the EE uses internally.
         private IntPtr _handle;
@@ -163,7 +163,12 @@ public static GCHandle FromIntPtr(IntPtr value)
 
         public override int GetHashCode() => _handle.GetHashCode();
 
-        public override bool Equals([NotNullWhen(true)] object? o) => o is GCHandle && _handle == ((GCHandle)o)._handle;
+        public override bool Equals([NotNullWhen(true)] object? o) => o is GCHandle other && Equals(other);
+
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(GCHandle other) => _handle == other._handle;
 
         public static bool operator ==(GCHandle a, GCHandle b) => (nint)a._handle == (nint)b._handle;
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Serialization/StreamingContext.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Serialization/StreamingContext.cs
index 3501457fa82d1e..1b3b86c0b9a646 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Serialization/StreamingContext.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Serialization/StreamingContext.cs
@@ -3,6 +3,8 @@
 
 using System.Diagnostics.CodeAnalysis;
 
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
+
 namespace System.Runtime.Serialization
 {
     public readonly struct StreamingContext
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationToken.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationToken.cs
index ab03e12e87be02..27f29cb0dd9498 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationToken.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationToken.cs
@@ -27,7 +27,7 @@ namespace System.Threading
     /// </para>
     /// </remarks>
     [DebuggerDisplay("IsCancellationRequested = {IsCancellationRequested}")]
-    public readonly struct CancellationToken
+    public readonly struct CancellationToken : IEquatable<CancellationToken>
     {
         // The backing TokenSource.
         // if null, it implicitly represents the same thing as new CancellationToken(false).
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.cs
index 6b6b86eb28b716..25a229c87ef66a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.cs
@@ -242,7 +242,7 @@ private bool WaitForSignal(int timeoutMs)
             }
         }
 
-        private struct Counts
+        private struct Counts : IEquatable<Counts>
         {
             private const byte SignalCountShift = 0;
             private const byte WaiterCountShift = 32;
@@ -350,10 +350,11 @@ public void DecrementCountOfWaitersSignaledToWake()
             public Counts InterlockedCompareExchange(Counts newCounts, Counts oldCounts) =>
                 new Counts(Interlocked.CompareExchange(ref _data, newCounts._data, oldCounts._data));
 
-            public static bool operator ==(Counts lhs, Counts rhs) => lhs._data == rhs._data;
-            public static bool operator !=(Counts lhs, Counts rhs) => lhs._data != rhs._data;
+            public static bool operator ==(Counts lhs, Counts rhs) => lhs.Equals(rhs);
+            public static bool operator !=(Counts lhs, Counts rhs) => !lhs.Equals(rhs);
 
-            public override bool Equals([NotNullWhen(true)] object? obj) => obj is Counts counts && _data == counts._data;
+            public override bool Equals([NotNullWhen(true)] object? obj) => obj is Counts other && Equals(other);
+            public bool Equals(Counts other) => _data == other._data;
             public override int GetHashCode() => (int)_data + (int)(_data >> 32);
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.ThreadCounts.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.ThreadCounts.cs
index 43aa0fcf7102cb..3242f165aff9a7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.ThreadCounts.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.ThreadCounts.cs
@@ -11,7 +11,7 @@ internal sealed partial class PortableThreadPool
         /// <summary>
         /// Tracks information on the number of threads we want/have in different states in our thread pool.
         /// </summary>
-        private struct ThreadCounts
+        private struct ThreadCounts : IEquatable<ThreadCounts>
         {
             // SOS's ThreadPool command depends on this layout
             private const byte NumProcessingWorkShift = 0;
@@ -126,7 +126,8 @@ public ThreadCounts InterlockedCompareExchange(ThreadCounts newCounts, ThreadCou
             public static bool operator ==(ThreadCounts lhs, ThreadCounts rhs) => lhs._data == rhs._data;
             public static bool operator !=(ThreadCounts lhs, ThreadCounts rhs) => lhs._data != rhs._data;
 
-            public override bool Equals([NotNullWhen(true)] object? obj) => obj is ThreadCounts other && _data == other._data;
+            public override bool Equals([NotNullWhen(true)] object? obj) => obj is ThreadCounts other && Equals(other);
+            public bool Equals(ThreadCounts other) => _data == other._data;
             public override int GetHashCode() => (int)_data + (int)(_data >> 32);
         }
     }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerTracking.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerTracking.cs
index 8c588965add43e..8a5f1d8bba581f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerTracking.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/PortableThreadPool.WorkerTracking.cs
@@ -58,7 +58,7 @@ private short GetAndResetHighWatermarkCountOfThreadsProcessingUserCallbacks()
         /// <summary>
         /// Tracks thread count information that is used when the <code>EnableWorkerTracking</code> config option is enabled.
         /// </summary>
-        private struct CountsOfThreadsProcessingUserCallbacks
+        private struct CountsOfThreadsProcessingUserCallbacks : IEquatable<CountsOfThreadsProcessingUserCallbacks>
         {
             private const byte CurrentShift = 0;
             private const byte HighWatermarkShift = 16;
@@ -114,13 +114,16 @@ public CountsOfThreadsProcessingUserCallbacks InterlockedCompareExchange(
 
             public static bool operator ==(
                 CountsOfThreadsProcessingUserCallbacks lhs,
-                CountsOfThreadsProcessingUserCallbacks rhs) => lhs._data == rhs._data;
+                CountsOfThreadsProcessingUserCallbacks rhs) => lhs.Equals(rhs);
             public static bool operator !=(
                 CountsOfThreadsProcessingUserCallbacks lhs,
-                CountsOfThreadsProcessingUserCallbacks rhs) => lhs._data != rhs._data;
+                CountsOfThreadsProcessingUserCallbacks rhs) => !lhs.Equals(rhs);
 
             public override bool Equals([NotNullWhen(true)] object? obj) =>
-                obj is CountsOfThreadsProcessingUserCallbacks other && _data == other._data;
+                obj is CountsOfThreadsProcessingUserCallbacks other && Equals(other);
+
+            public bool Equals(CountsOfThreadsProcessingUserCallbacks other) => _data == other._data;
+
             public override int GetHashCode() => (int)_data;
         }
     }
diff --git a/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.AdjustmentRule.cs b/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.AdjustmentRule.cs
index 6f53ab75ce3511..7c754b4f285708 100644
--- a/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.AdjustmentRule.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.AdjustmentRule.cs
@@ -56,6 +56,12 @@ public bool Equals([NotNullWhen(true)] AdjustmentRule? other) =>
                 _daylightTransitionEnd.Equals(other._daylightTransitionEnd) &&
                 _daylightTransitionStart.Equals(other._daylightTransitionStart);
 
+            /// <summary>Indicates whether the current instance is equal to another instance.</summary>
+            /// <param name="obj">An instance to compare with this instance.</param>
+            /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+            public override bool Equals([NotNullWhen(true)] object? obj) =>
+                obj is AdjustmentRule other && Equals(other);
+
             public override int GetHashCode() => _dateStart.GetHashCode();
 
             private AdjustmentRule(
diff --git a/src/libraries/System.Private.CoreLib/src/System/UIntPtr.cs b/src/libraries/System.Private.CoreLib/src/System/UIntPtr.cs
index bc7859c0d18d9e..12a2dce1d7258f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/UIntPtr.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/UIntPtr.cs
@@ -11,6 +11,8 @@
 using Internal.Runtime.CompilerServices;
 
 #pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
+
 #if TARGET_64BIT
 using nuint_t = System.UInt64;
 #else
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/BinaryXml/XmlBinaryReader.cs b/src/libraries/System.Private.Xml/src/System/Xml/BinaryXml/XmlBinaryReader.cs
index 074f795ea54c07..33d1e3dff11c23 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/BinaryXml/XmlBinaryReader.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/BinaryXml/XmlBinaryReader.cs
@@ -59,7 +59,7 @@ private enum ScanState
         };
 
         // Note: also used by XmlBinaryWriter
-        internal struct QName
+        internal struct QName : IEquatable<QName>
         {
             public string prefix;
             public string localname;
@@ -95,45 +95,26 @@ public void CheckPrefixNS(string prefix, string namespaceUri)
                     throw new XmlException(SR.XmlBinary_NoRemapPrefix, new string[] { prefix, this.namespaceUri, namespaceUri });
             }
 
-            public override int GetHashCode()
-            {
-                return this.prefix.GetHashCode() ^ this.localname.GetHashCode();
-            }
+            public int GetNSHashCode() =>
+                HashCode.Combine(this.namespaceUri, this.localname);
 
-            public int GetNSHashCode()
-            {
-                return HashCode.Combine(this.namespaceUri, this.localname);
-            }
+            public override int GetHashCode() =>
+                this.prefix.GetHashCode() ^ this.localname.GetHashCode();
 
+            public override bool Equals([NotNullWhen(true)] object? other) =>
+                other is QName qname && Equals(qname);
 
-            public override bool Equals([NotNullWhen(true)] object? other)
-            {
-                if (other is QName that)
-                {
-                    return this == that;
-                }
-                return false;
-            }
+            public bool Equals(QName other) =>
+                prefix == other.prefix &&
+                localname == other.localname &&
+                namespaceUri == other.namespaceUri;
 
-            public override string ToString()
-            {
-                if (prefix.Length == 0)
-                    return this.localname;
-                else
-                    return $"{this.prefix}:{this.localname}";
-            }
+            public static bool operator ==(QName a, QName b) => a.Equals(b);
 
-            public static bool operator ==(QName a, QName b)
-            {
-                return ((a.prefix == b.prefix)
-                    && (a.localname == b.localname)
-                    && (a.namespaceUri == b.namespaceUri));
-            }
+            public static bool operator !=(QName a, QName b) => !a.Equals(b);
 
-            public static bool operator !=(QName a, QName b)
-            {
-                return !(a == b);
-            }
+            public override string ToString() =>
+                prefix.Length == 0 ? localname : $"{this.prefix}:{this.localname}";
         };
 
         private struct ElemInfo
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Xsl/Pair.cs b/src/libraries/System.Private.Xml/src/System/Xml/Xsl/Pair.cs
index 8e3e1a4b841a76..33b4fe98b3f922 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Xsl/Pair.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Xsl/Pair.cs
@@ -7,49 +7,34 @@
 
 namespace System.Xml.Xsl
 {
-    internal struct Int32Pair
+    internal readonly struct Int32Pair : IEquatable<Int32Pair>
     {
-        private readonly int _left;
-        private readonly int _right;
-
         public Int32Pair(int left, int right)
         {
-            _left = left;
-            _right = right;
+            Left = left;
+            Right = right;
         }
 
-        public int Left { get { return _left; } }
-        public int Right { get { return _right; } }
+        public int Left { get; }
+        public int Right { get; }
 
-        public override bool Equals([NotNullWhen(true)] object? other)
-        {
-            if (other is Int32Pair)
-            {
-                Int32Pair o = (Int32Pair)other;
-                return _left == o._left && _right == o._right;
-            }
+        public override bool Equals([NotNullWhen(true)] object? other) =>
+            other is Int32Pair o && Equals(o);
 
-            return false;
-        }
+        public bool Equals(Int32Pair other) => Left == other.Left && Right == other.Right;
 
-        public override int GetHashCode()
-        {
-            return _left.GetHashCode() ^ _right.GetHashCode();
-        }
+        public override int GetHashCode() => Left.GetHashCode() ^ Right.GetHashCode();
     }
 
-    internal struct StringPair
+    internal readonly struct StringPair
     {
-        private readonly string _left;
-        private readonly string _right;
-
         public StringPair(string left, string right)
         {
-            _left = left;
-            _right = right;
+            Left = left;
+            Right = right;
         }
 
-        public string Left { get { return _left; } }
-        public string Right { get { return _right; } }
+        public string Left { get; }
+        public string Right { get; }
     }
 }
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XmlQueryCardinality.cs b/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XmlQueryCardinality.cs
index 1046765a2d3b23..a95ce13c1737c9 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XmlQueryCardinality.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Xsl/XmlQueryCardinality.cs
@@ -11,7 +11,7 @@ namespace System.Xml.Xsl
     /// Cardinality of part of XmlQueryType
     /// struct is being used because enum doesn't allow members
     /// </summary>
-    internal struct XmlQueryCardinality
+    internal readonly struct XmlQueryCardinality : IEquatable<XmlQueryCardinality>
     {
         private readonly int _value;
 
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheExpires.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheExpires.cs
index e4eab06b7adb31..f9cc0fd36dadf0 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheExpires.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheExpires.cs
@@ -13,7 +13,7 @@
 
 namespace System.Runtime.Caching
 {
-    internal struct ExpiresEntryRef
+    internal readonly struct ExpiresEntryRef : IEquatable<ExpiresEntryRef>
     {
         internal static readonly ExpiresEntryRef INVALID = new ExpiresEntryRef(0, 0);
 
@@ -31,55 +31,18 @@ internal ExpiresEntryRef(int pageIndex, int entryIndex)
             _ref = ((((uint)pageIndex) << PAGE_SHIFT) | (((uint)(entryIndex)) & ENTRY_MASK));
         }
 
-        public override bool Equals(object value)
-        {
-            if (value is ExpiresEntryRef)
-            {
-                return _ref == ((ExpiresEntryRef)value)._ref;
-            }
+        public override bool Equals(object value) => value is ExpiresEntryRef other && Equals(other);
 
-            return false;
-        }
+        public bool Equals(ExpiresEntryRef other) => _ref == other._ref;
 
-        public static bool operator !=(ExpiresEntryRef r1, ExpiresEntryRef r2)
-        {
-            return r1._ref != r2._ref;
-        }
-        public static bool operator ==(ExpiresEntryRef r1, ExpiresEntryRef r2)
-        {
-            return r1._ref == r2._ref;
-        }
+        public static bool operator ==(ExpiresEntryRef r1, ExpiresEntryRef r2) => r1.Equals(r2);
+        public static bool operator !=(ExpiresEntryRef r1, ExpiresEntryRef r2) => !r1.Equals(r2);
 
-        public override int GetHashCode()
-        {
-            return (int)_ref;
-        }
+        public override int GetHashCode() => (int)_ref;
 
-        internal int PageIndex
-        {
-            get
-            {
-                int result = (int)(_ref >> PAGE_SHIFT);
-                return result;
-            }
-        }
-
-        internal int Index
-        {
-            get
-            {
-                int result = (int)(_ref & ENTRY_MASK);
-                return result;
-            }
-        }
-
-        internal bool IsInvalid
-        {
-            get
-            {
-                return _ref == 0;
-            }
-        }
+        internal int PageIndex => (int)(_ref >> PAGE_SHIFT);
+        internal int Index => (int)(_ref & ENTRY_MASK);
+        internal bool IsInvalid => _ref == 0;
     }
 
     [StructLayout(LayoutKind.Explicit)]
diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheUsage.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheUsage.cs
index 73ed9f30d3d5c9..7b7ea642792110 100644
--- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheUsage.cs
+++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/CacheUsage.cs
@@ -13,7 +13,7 @@
 
 namespace System.Runtime.Caching
 {
-    internal struct UsageEntryRef
+    internal readonly struct UsageEntryRef : IEquatable<UsageEntryRef>
     {
         internal static readonly UsageEntryRef INVALID = new UsageEntryRef(0, 0);
 
@@ -31,38 +31,18 @@ internal UsageEntryRef(int pageIndex, int entryIndex)
             _ref = ((((uint)pageIndex) << PAGE_SHIFT) | (((uint)(entryIndex)) & ENTRY_MASK));
         }
 
-        public override bool Equals(object value)
-        {
-            if (value is UsageEntryRef)
-            {
-                return _ref == ((UsageEntryRef)value)._ref;
-            }
+        public override bool Equals(object value) =>
+            value is UsageEntryRef other && Equals(other);
 
-            return false;
-        }
-        public static bool operator ==(UsageEntryRef r1, UsageEntryRef r2)
-        {
-            return r1._ref == r2._ref;
-        }
+        public bool Equals(UsageEntryRef other) => _ref == other._ref;
 
-        public static bool operator !=(UsageEntryRef r1, UsageEntryRef r2)
-        {
-            return r1._ref != r2._ref;
-        }
+        public static bool operator ==(UsageEntryRef r1, UsageEntryRef r2) => r1.Equals(r2);
 
-        public override int GetHashCode()
-        {
-            return (int)_ref;
-        }
+        public static bool operator !=(UsageEntryRef r1, UsageEntryRef r2) => !r1.Equals(r2);
 
-        internal int PageIndex
-        {
-            get
-            {
-                int result = (int)(_ref >> PAGE_SHIFT);
-                return result;
-            }
-        }
+        public override int GetHashCode() => (int)_ref;
+
+        internal int PageIndex => (int)(_ref >> PAGE_SHIFT);
 
         internal int Ref1Index
         {
@@ -84,29 +64,11 @@ internal int Ref2Index
             }
         }
 
-        internal bool IsRef1
-        {
-            get
-            {
-                return ((int)(sbyte)(_ref & ENTRY_MASK)) > 0;
-            }
-        }
+        internal bool IsRef1 => ((int)(sbyte)(_ref & ENTRY_MASK)) > 0;
 
-        internal bool IsRef2
-        {
-            get
-            {
-                return ((int)(sbyte)(_ref & ENTRY_MASK)) < 0;
-            }
-        }
+        internal bool IsRef2 => ((int)(sbyte)(_ref & ENTRY_MASK)) < 0;
 
-        internal bool IsInvalid
-        {
-            get
-            {
-                return _ref == 0;
-            }
-        }
+        internal bool IsInvalid => _ref == 0;
     }
 
     internal struct UsageEntryLink
diff --git a/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs b/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
index 901b76346b82c1..e58de5b8a040a9 100644
--- a/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
+++ b/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
@@ -98,7 +98,7 @@ public sealed partial class AllowReversePInvokeCallsAttribute : System.Attribute
     {
         public AllowReversePInvokeCallsAttribute() { }
     }
-    public readonly partial struct ArrayWithOffset
+    public readonly partial struct ArrayWithOffset : System.IEquatable<System.Runtime.InteropServices.ArrayWithOffset>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/GCHandleTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/GCHandleTests.cs
index bf5ec1713cdbc6..8a79b7a66db456 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/GCHandleTests.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/GCHandleTests.cs
@@ -138,6 +138,7 @@ public void Equals_Object_ReturnsExpected(GCHandle handle, object other, bool ex
                 Assert.Equal(expected, handle.Equals(other));
                 if (other is GCHandle otherHandle)
                 {
+                    Assert.Equal(expected, handle.Equals(otherHandle));
                     Assert.Equal(expected, handle == otherHandle);
                     Assert.Equal(!expected, handle != otherHandle);
                 }
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index c57c5b13cc1190..57c9f8368994eb 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -4826,7 +4826,7 @@ public MissingMethodException(string? message, System.Exception? inner) { }
         public MissingMethodException(string? className, string? methodName) { }
         public override string Message { get { throw null; } }
     }
-    public partial struct ModuleHandle
+    public partial struct ModuleHandle : System.IEquatable<System.ModuleHandle>
     {
         private object _dummy;
         private int _dummyPrimitive;
@@ -6367,6 +6367,7 @@ internal AdjustmentRule() { }
             public static System.TimeZoneInfo.AdjustmentRule CreateAdjustmentRule(System.DateTime dateStart, System.DateTime dateEnd, System.TimeSpan daylightDelta, System.TimeZoneInfo.TransitionTime daylightTransitionStart, System.TimeZoneInfo.TransitionTime daylightTransitionEnd) { throw null; }
             public static System.TimeZoneInfo.AdjustmentRule CreateAdjustmentRule(System.DateTime dateStart, System.DateTime dateEnd, System.TimeSpan daylightDelta, System.TimeZoneInfo.TransitionTime daylightTransitionStart, System.TimeZoneInfo.TransitionTime daylightTransitionEnd, System.TimeSpan baseUtcOffsetDelta) { throw null; }
             public bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] System.TimeZoneInfo.AdjustmentRule? other) { throw null; }
+            public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; }
             public override int GetHashCode() { throw null; }
             void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object? sender) { }
             void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
@@ -11648,7 +11649,7 @@ protected CustomAttributeFormatException(System.Runtime.Serialization.Serializat
         public CustomAttributeFormatException(string? message) { }
         public CustomAttributeFormatException(string? message, System.Exception? inner) { }
     }
-    public readonly partial struct CustomAttributeNamedArgument
+    public readonly partial struct CustomAttributeNamedArgument : System.IEquatable<System.Reflection.CustomAttributeNamedArgument>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
@@ -11658,13 +11659,14 @@ public readonly partial struct CustomAttributeNamedArgument
         public System.Reflection.MemberInfo MemberInfo { get { throw null; } }
         public string MemberName { get { throw null; } }
         public System.Reflection.CustomAttributeTypedArgument TypedValue { get { throw null; } }
-        public override bool Equals(object? obj) { throw null; }
+        public bool Equals(System.Reflection.CustomAttributeNamedArgument other) { throw null; }
+        public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; }
         public override int GetHashCode() { throw null; }
         public static bool operator ==(System.Reflection.CustomAttributeNamedArgument left, System.Reflection.CustomAttributeNamedArgument right) { throw null; }
         public static bool operator !=(System.Reflection.CustomAttributeNamedArgument left, System.Reflection.CustomAttributeNamedArgument right) { throw null; }
         public override string ToString() { throw null; }
     }
-    public readonly partial struct CustomAttributeTypedArgument
+    public readonly partial struct CustomAttributeTypedArgument : System.IEquatable<System.Reflection.CustomAttributeTypedArgument>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
@@ -11672,7 +11674,8 @@ public readonly partial struct CustomAttributeTypedArgument
         public CustomAttributeTypedArgument(System.Type argumentType, object? value) { throw null; }
         public System.Type ArgumentType { get { throw null; } }
         public object? Value { get { throw null; } }
-        public override bool Equals(object? obj) { throw null; }
+        public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; }
+        public bool Equals(System.Reflection.CustomAttributeTypedArgument other) { throw null; }
         public override int GetHashCode() { throw null; }
         public static bool operator ==(System.Reflection.CustomAttributeTypedArgument left, System.Reflection.CustomAttributeTypedArgument right) { throw null; }
         public static bool operator !=(System.Reflection.CustomAttributeTypedArgument left, System.Reflection.CustomAttributeTypedArgument right) { throw null; }
@@ -13493,7 +13496,7 @@ public sealed partial class FieldOffsetAttribute : System.Attribute
         public FieldOffsetAttribute(int offset) { }
         public int Value { get { throw null; } }
     }
-    public partial struct GCHandle
+    public partial struct GCHandle : System.IEquatable<System.Runtime.InteropServices.GCHandle>
     {
         private int _dummyPrimitive;
         public bool IsAllocated { get { throw null; } }
@@ -13502,6 +13505,7 @@ public partial struct GCHandle
         public static System.Runtime.InteropServices.GCHandle Alloc(object? value) { throw null; }
         public static System.Runtime.InteropServices.GCHandle Alloc(object? value, System.Runtime.InteropServices.GCHandleType type) { throw null; }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? o) { throw null; }
+        public bool Equals(System.Runtime.InteropServices.GCHandle other) { throw null; }
         public void Free() { }
         public static System.Runtime.InteropServices.GCHandle FromIntPtr(System.IntPtr value) { throw null; }
         public override int GetHashCode() { throw null; }
@@ -14770,7 +14774,7 @@ public static partial class Utf8
 }
 namespace System.Threading
 {
-    public readonly partial struct CancellationToken
+    public readonly partial struct CancellationToken : System.IEquatable<System.Threading.CancellationToken>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
diff --git a/src/libraries/System.Runtime/tests/System/Reflection/CustomAttribute_Named_Typed_ArgumentTests.cs b/src/libraries/System.Runtime/tests/System/Reflection/CustomAttribute_Named_Typed_ArgumentTests.cs
index 4460797182c873..c406e36ea21c3f 100644
--- a/src/libraries/System.Runtime/tests/System/Reflection/CustomAttribute_Named_Typed_ArgumentTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Reflection/CustomAttribute_Named_Typed_ArgumentTests.cs
@@ -52,6 +52,28 @@ public static void Test_CustomAttributeTypedArgument_Constructor()
             Assert.True(false, "Expected to find MyAttr Attribute");
         }
 
+        [Fact]
+        public static void Test_CustomAttributeTypedArgument_Equals()
+        {
+            Type t = typeof(MyClass);
+            foreach (CustomAttributeData cad in CustomAttributeData.GetCustomAttributes(t))
+            {
+                foreach (CustomAttributeTypedArgument cata in cad.ConstructorArguments)
+                {
+                    Assert.True(cata.Equals(cata));
+                    Assert.True(cata.Equals((object)cata));
+
+                    var notEqualArgument = new CustomAttributeTypedArgument(new [] { new CustomAttributeTypedArgument(0) });
+                    Assert.False(cata.Equals(notEqualArgument));
+                    Assert.False(cata.Equals((object)notEqualArgument));
+
+                    return;
+                }
+            }
+
+            Assert.True(false, "Expected to find MyAttr Attribute");
+        }
+
         [Fact]
         public static void Test_CustomAttributeTypedArgument_ToString()
         {
diff --git a/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.netcoreapp.cs b/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.netcoreapp.cs
index 3fd806b0f56492..1298a7c23d6909 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.netcoreapp.cs
+++ b/src/libraries/System.ServiceProcess.ServiceController/ref/System.ServiceProcess.ServiceController.netcoreapp.cs
@@ -10,4 +10,7 @@ public partial class ServiceController : System.ComponentModel.Component
     {
         public void Stop(bool stopDependentServices) { }
     }
+    public readonly partial struct SessionChangeDescription : System.IEquatable<System.ServiceProcess.SessionChangeDescription>
+    {
+    }
 }
diff --git a/src/libraries/System.ServiceProcess.ServiceController/src/System.ServiceProcess.ServiceController.csproj b/src/libraries/System.ServiceProcess.ServiceController/src/System.ServiceProcess.ServiceController.csproj
index 8fd0582994dd4e..fac46aed04ba2c 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/src/System.ServiceProcess.ServiceController.csproj
+++ b/src/libraries/System.ServiceProcess.ServiceController/src/System.ServiceProcess.ServiceController.csproj
@@ -17,6 +17,8 @@ System.ServiceProcess.ServiceType</PackageDescription>
     <IsPartialFacadeAssembly Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETFramework'">true</IsPartialFacadeAssembly>
     <OmitResources Condition="'$(IsPartialFacadeAssembly)' == 'true'">true</OmitResources>
     <GeneratePlatformNotSupportedAssemblyMessage Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' != 'true'">SR.PlatformNotSupported_ServiceController</GeneratePlatformNotSupportedAssemblyMessage>
+    <!-- we cannot add API on .NETStandard since it would be absent on .NETFramework, suppress warnings that require API changes -->
+    <NoWarn Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) == '.NETStandard'">$(NoWarn);CA1066</NoWarn>
   </PropertyGroup>
   <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true' and '$(TargetsWindows)' == 'true'">
     <Compile Include="$(CommonPath)System\Text\ValueStringBuilder.cs"
diff --git a/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/SessionChangeDescription.cs b/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/SessionChangeDescription.cs
index bc11eaeea10918..e4924e93c414e5 100644
--- a/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/SessionChangeDescription.cs
+++ b/src/libraries/System.ServiceProcess.ServiceController/src/System/ServiceProcess/SessionChangeDescription.cs
@@ -6,6 +6,9 @@
 namespace System.ServiceProcess
 {
     public readonly struct SessionChangeDescription
+#if NETCOREAPP
+        : IEquatable<SessionChangeDescription>
+#endif
     {
         internal SessionChangeDescription(SessionChangeReason reason, int id)
         {
@@ -17,34 +20,20 @@ internal SessionChangeDescription(SessionChangeReason reason, int id)
 
         public int SessionId { get; }
 
-        public override bool Equals([NotNullWhen(true)] object? obj)
-        {
-            if (!(obj is SessionChangeDescription))
-            {
-                return false;
-            }
+        public override int GetHashCode() =>
+            (int)Reason ^ SessionId;
 
-            return Equals((SessionChangeDescription)obj);
-        }
+        public override bool Equals([NotNullWhen(true)] object? obj) =>
+            obj is SessionChangeDescription other && Equals(other);
 
-        public override int GetHashCode()
-        {
-            return (int)Reason ^ SessionId;
-        }
+        public bool Equals(SessionChangeDescription changeDescription) =>
+            (Reason == changeDescription.Reason) &&
+            (SessionId == changeDescription.SessionId);
 
-        public bool Equals(SessionChangeDescription changeDescription)
-        {
-            return (Reason == changeDescription.Reason) && (SessionId == changeDescription.SessionId);
-        }
+        public static bool operator ==(SessionChangeDescription a, SessionChangeDescription b) =>
+            a.Equals(b);
 
-        public static bool operator ==(SessionChangeDescription a, SessionChangeDescription b)
-        {
-            return a.Equals(b);
-        }
-
-        public static bool operator !=(SessionChangeDescription a, SessionChangeDescription b)
-        {
-            return !a.Equals(b);
-        }
+        public static bool operator !=(SessionChangeDescription a, SessionChangeDescription b) =>
+            !a.Equals(b);
     }
 }
diff --git a/src/libraries/System.Speech/src/Internal/Synthesis/EngineSiteSapi.cs b/src/libraries/System.Speech/src/Internal/Synthesis/EngineSiteSapi.cs
index d6bf03a57d2f17..e44843b0c81938 100644
--- a/src/libraries/System.Speech/src/Internal/Synthesis/EngineSiteSapi.cs
+++ b/src/libraries/System.Speech/src/Internal/Synthesis/EngineSiteSapi.cs
@@ -176,8 +176,9 @@ internal interface ISpEngineSite
         void CompleteSkip(int skipped);
         void LoadResource([MarshalAs(UnmanagedType.LPWStr)] string resource, ref string mediaType, out IStream stream);
     }
+
     [StructLayout(LayoutKind.Sequential)]
-    internal struct SpeechEventSapi
+    internal struct SpeechEventSapi : IEquatable<SpeechEventSapi>
     {
         public short EventId;
         public short ParameterType;
@@ -185,27 +186,22 @@ internal struct SpeechEventSapi
         public long AudioStreamOffset;
         public IntPtr Param1;   // Always just a numeric type - contains no unmanaged resources so does not need special clean-up.
         public IntPtr Param2;   // Can be a numeric type, or pointer to string or object. Use SafeSapiLParamHandle to cleanup.
-        public static bool operator ==(SpeechEventSapi event1, SpeechEventSapi event2)
-        {
-            return event1.EventId == event2.EventId && event1.ParameterType == event2.ParameterType && event1.StreamNumber == event2.StreamNumber && event1.AudioStreamOffset == event2.AudioStreamOffset && event1.Param1 == event2.Param1 && event1.Param2 == event2.Param2;
-        }
-        public static bool operator !=(SpeechEventSapi event1, SpeechEventSapi event2)
-        {
-            return !(event1 == event2);
-        }
-        public override bool Equals(object obj)
-        {
-            if (!(obj is SpeechEventSapi))
-            {
-                return false;
-            }
 
-            return this == (SpeechEventSapi)obj;
-        }
-        public override int GetHashCode()
-        {
-            return base.GetHashCode();
-        }
+        public static bool operator ==(SpeechEventSapi event1, SpeechEventSapi event2) => event1.Equals(event2);
+        public static bool operator !=(SpeechEventSapi event1, SpeechEventSapi event2) => !event1.Equals(event2);
+
+        public override bool Equals(object obj) =>
+            obj is SpeechEventSapi other && Equals(other);
+
+        public bool Equals(SpeechEventSapi other) =>
+            EventId == other.EventId &&
+            ParameterType == other.ParameterType &&
+            StreamNumber == other.StreamNumber &&
+            AudioStreamOffset == other.AudioStreamOffset &&
+            Param1 == other.Param1 &&
+            Param2 == other.Param2;
+
+        public override int GetHashCode() => base.GetHashCode();
     }
 
     #endregion
diff --git a/src/libraries/System.Text.Encodings.Web/src/Polyfills/System.Text.Rune.netstandard20.cs b/src/libraries/System.Text.Encodings.Web/src/Polyfills/System.Text.Rune.netstandard20.cs
index 66c637eda2a2b1..774ee9e426c7e5 100644
--- a/src/libraries/System.Text.Encodings.Web/src/Polyfills/System.Text.Rune.netstandard20.cs
+++ b/src/libraries/System.Text.Encodings.Web/src/Polyfills/System.Text.Rune.netstandard20.cs
@@ -14,7 +14,7 @@
 
 namespace System.Text
 {
-    internal readonly struct Rune
+    internal readonly struct Rune : IEquatable<Rune>
     {
         private const int MaxUtf16CharsPerRune = 2; // supplementary plane code points are encoded as 2 UTF-16 code units
 
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicMatch.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicMatch.cs
index c6754b8577b0dc..5ba715c25ef4c8 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicMatch.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicMatch.cs
@@ -5,7 +5,7 @@
 
 namespace System.Text.RegularExpressions.Symbolic
 {
-    internal readonly struct SymbolicMatch
+    internal readonly struct SymbolicMatch : IEquatable<SymbolicMatch>
     {
         /// <summary>Indicates failure to find a match.</summary>
         internal static SymbolicMatch NoMatch => new SymbolicMatch(-1, -1);
@@ -20,17 +20,21 @@ public SymbolicMatch(int index, int length)
         }
 
         public int Index { get; }
+
         public int Length { get; }
+
         public bool Success => Index >= 0;
 
         public static bool operator ==(SymbolicMatch left, SymbolicMatch right) =>
-            left.Index == right.Index && left.Length == right.Length;
+            left.Equals(right);
 
         public static bool operator !=(SymbolicMatch left, SymbolicMatch right) =>
-            !(left == right);
+            !left.Equals(right);
 
         public override bool Equals([NotNullWhen(true)] object? obj) =>
-            obj is SymbolicMatch other && this == other;
+            obj is SymbolicMatch other && Equals(other);
+
+        public bool Equals(SymbolicMatch other) => Index == other.Index && Length == other.Length;
 
         public override int GetHashCode() => HashCode.Combine(Index, Length);
     }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexInfo.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexInfo.cs
index ba522d513392c7..4e60696eb07174 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexInfo.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexInfo.cs
@@ -4,7 +4,7 @@
 namespace System.Text.RegularExpressions.Symbolic
 {
     /// <summary>Misc information of structural properties of a <see cref="SymbolicRegexNode{S}"/> that is computed bottom up.</summary>
-    internal readonly struct SymbolicRegexInfo
+    internal readonly struct SymbolicRegexInfo : IEquatable<SymbolicRegexInfo>
     {
         private const uint IsAlwaysNullableMask = 1;
         private const uint StartsWithLineAnchorMask = 2;
@@ -177,7 +177,9 @@ public static SymbolicRegexInfo Not(SymbolicRegexInfo info) =>
                 containsSomeCharacter: info.ContainsSomeCharacter,
                 isLazy: info.IsLazy);
 
-        public override bool Equals(object? obj) => obj is SymbolicRegexInfo i && i._info == _info;
+        public override bool Equals(object? obj) => obj is SymbolicRegexInfo i && Equals(i);
+
+        public bool Equals(SymbolicRegexInfo other) => _info == other._info;
 
         public override int GetHashCode() => _info.GetHashCode();
 
diff --git a/src/libraries/System.Threading/ref/System.Threading.cs b/src/libraries/System.Threading/ref/System.Threading.cs
index 1237c49cecaedc..3c5f1268e88731 100644
--- a/src/libraries/System.Threading/ref/System.Threading.cs
+++ b/src/libraries/System.Threading/ref/System.Threading.cs
@@ -235,7 +235,7 @@ public static partial class LazyInitializer
         public static T EnsureInitialized<T>([System.Diagnostics.CodeAnalysis.NotNullAttribute] ref T? target, System.Func<T> valueFactory) where T : class { throw null; }
         public static T EnsureInitialized<T>([System.Diagnostics.CodeAnalysis.NotNullAttribute] ref T? target, [System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("syncLock")] ref object? syncLock, System.Func<T> valueFactory) where T : class { throw null; }
     }
-    public partial struct LockCookie
+    public partial struct LockCookie : System.IEquatable<System.Threading.LockCookie>
     {
         private int _dummyPrimitive;
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; }
diff --git a/src/libraries/System.Threading/src/System/Threading/LockCookie.cs b/src/libraries/System.Threading/src/System/Threading/LockCookie.cs
index 6a76ceb023d0a0..a9c9011179f8fb 100644
--- a/src/libraries/System.Threading/src/System/Threading/LockCookie.cs
+++ b/src/libraries/System.Threading/src/System/Threading/LockCookie.cs
@@ -9,40 +9,27 @@ namespace System.Threading
     /// Stores the lock state of a <see cref="ReaderWriterLock"/> before its lock state is changed, such that the lock state may
     /// later be restored.
     /// </summary>
-    public struct LockCookie
+    public struct LockCookie : IEquatable<LockCookie>
     {
         internal LockCookieFlags _flags;
         internal ushort _readerLevel;
         internal ushort _writerLevel;
         internal int _threadID;
 
-        public override int GetHashCode()
-        {
-            return (int)_flags + _readerLevel + _writerLevel + _threadID;
-        }
+        public override int GetHashCode() =>
+            (int)_flags + _readerLevel + _writerLevel + _threadID;
 
-        public override bool Equals([NotNullWhen(true)] object? obj)
-        {
-            return obj is LockCookie && Equals((LockCookie)obj);
-        }
+        public override bool Equals([NotNullWhen(true)] object? obj) =>
+            obj is LockCookie other && Equals(other);
 
-        public bool Equals(LockCookie obj)
-        {
-            return
-                _flags == obj._flags &&
-                _readerLevel == obj._readerLevel &&
-                _writerLevel == obj._writerLevel &&
-                _threadID == obj._threadID;
-        }
+        public bool Equals(LockCookie obj) =>
+            _flags == obj._flags &&
+            _readerLevel == obj._readerLevel &&
+            _writerLevel == obj._writerLevel &&
+            _threadID == obj._threadID;
 
-        public static bool operator ==(LockCookie a, LockCookie b)
-        {
-            return a.Equals(b);
-        }
+        public static bool operator ==(LockCookie a, LockCookie b) => a.Equals(b);
 
-        public static bool operator !=(LockCookie a, LockCookie b)
-        {
-            return !(a == b);
-        }
+        public static bool operator !=(LockCookie a, LockCookie b) => !a.Equals(b);
     }
 }
diff --git a/src/libraries/System.Transactions.Local/ref/System.Transactions.Local.cs b/src/libraries/System.Transactions.Local/ref/System.Transactions.Local.cs
index 91804388b42fa2..f52ae1ffd8b918 100644
--- a/src/libraries/System.Transactions.Local/ref/System.Transactions.Local.cs
+++ b/src/libraries/System.Transactions.Local/ref/System.Transactions.Local.cs
@@ -202,12 +202,13 @@ protected TransactionManagerCommunicationException(System.Runtime.Serialization.
         public TransactionManagerCommunicationException(string? message) { }
         public TransactionManagerCommunicationException(string? message, System.Exception? innerException) { }
     }
-    public partial struct TransactionOptions
+    public partial struct TransactionOptions : System.IEquatable<System.Transactions.TransactionOptions>
     {
-        private int _dummyPrimitive;
+        private readonly int _dummyPrimitive;
         public System.Transactions.IsolationLevel IsolationLevel { get { throw null; } set { } }
         public System.TimeSpan Timeout { get { throw null; } set { } }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; }
+        public bool Equals(System.Transactions.TransactionOptions other) { throw null; }
         public override int GetHashCode() { throw null; }
         public static bool operator ==(System.Transactions.TransactionOptions x, System.Transactions.TransactionOptions y) { throw null; }
         public static bool operator !=(System.Transactions.TransactionOptions x, System.Transactions.TransactionOptions y) { throw null; }
diff --git a/src/libraries/System.Transactions.Local/src/System/Transactions/TransactionOptions.cs b/src/libraries/System.Transactions.Local/src/System/Transactions/TransactionOptions.cs
index 1fa34283bb4557..4ce7bb4bd1394a 100644
--- a/src/libraries/System.Transactions.Local/src/System/Transactions/TransactionOptions.cs
+++ b/src/libraries/System.Transactions.Local/src/System/Transactions/TransactionOptions.cs
@@ -5,7 +5,7 @@
 
 namespace System.Transactions
 {
-    public struct TransactionOptions
+    public struct TransactionOptions : IEquatable<TransactionOptions>
     {
         private TimeSpan _timeout;
         private IsolationLevel _isolationLevel;
@@ -26,7 +26,10 @@ public IsolationLevel IsolationLevel
 
         public override bool Equals([NotNullWhen(true)] object? obj) => obj is TransactionOptions transactionOptions && Equals(transactionOptions);
 
-        private bool Equals(TransactionOptions other) =>
+        /// <summary>Indicates whether the current instance is equal to another instance of the same type.</summary>
+        /// <param name="other">An instance to compare with this instance.</param>
+        /// <returns>true if the current instance is equal to the other instance; otherwise, false.</returns>
+        public bool Equals(TransactionOptions other) =>
             _timeout == other._timeout &&
             _isolationLevel == other._isolationLevel;
 
diff --git a/src/mono/System.Private.CoreLib/src/Mono/RuntimeHandles.cs b/src/mono/System.Private.CoreLib/src/Mono/RuntimeHandles.cs
index c62dde66120498..90b612313c19d4 100644
--- a/src/mono/System.Private.CoreLib/src/Mono/RuntimeHandles.cs
+++ b/src/mono/System.Private.CoreLib/src/Mono/RuntimeHandles.cs
@@ -7,7 +7,7 @@
 
 namespace Mono
 {
-    internal unsafe struct RuntimeClassHandle
+    internal unsafe struct RuntimeClassHandle : IEquatable<RuntimeClassHandle>
     {
         private readonly RuntimeStructs.MonoClass* value;
 
@@ -125,7 +125,7 @@ private int GetConstraintsCount()
         }
     }
 
-    internal struct RuntimeEventHandle
+    internal struct RuntimeEventHandle : IEquatable<RuntimeEventHandle>
     {
         private readonly IntPtr value;
 
@@ -165,7 +165,7 @@ public override int GetHashCode()
         }
     }
 
-    internal struct RuntimePropertyHandle
+    internal struct RuntimePropertyHandle : IEquatable<RuntimePropertyHandle>
     {
         private readonly IntPtr value;
 
diff --git a/src/mono/System.Private.CoreLib/src/System/ModuleHandle.cs b/src/mono/System.Private.CoreLib/src/System/ModuleHandle.cs
index 9f73b99fb6db90..c30bf25582a3a5 100644
--- a/src/mono/System.Private.CoreLib/src/System/ModuleHandle.cs
+++ b/src/mono/System.Private.CoreLib/src/System/ModuleHandle.cs
@@ -6,7 +6,7 @@
 
 namespace System
 {
-    public struct ModuleHandle
+    public struct ModuleHandle : IEquatable<ModuleHandle>
     {
         private readonly IntPtr value;
 
diff --git a/src/mono/System.Private.CoreLib/src/System/Nullable.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Nullable.Mono.cs
index 23f7668e73549b..c1204551999226 100644
--- a/src/mono/System.Private.CoreLib/src/System/Nullable.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Nullable.Mono.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#pragma warning disable CA1066 // Implement IEquatable when overriding Object.Equals
+
 namespace System
 {
     public partial struct Nullable<T>
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs b/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs
index af1cead1c95935..9b9c5a410cf2ff 100644
--- a/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs
@@ -14,7 +14,7 @@
 
 namespace Microsoft.WebAssembly.Diagnostics
 {
-    public struct SessionId
+    public struct SessionId : IEquatable<SessionId>
     {
         public readonly string sessionId;
 
@@ -26,7 +26,9 @@ public SessionId(string sessionId)
         // hashset treats 0 as unset
         public override int GetHashCode() => sessionId?.GetHashCode() ?? -1;
 
-        public override bool Equals(object obj) => (obj is SessionId) ? ((SessionId)obj).sessionId == sessionId : false;
+        public override bool Equals(object obj) => obj is SessionId other && Equals(other);
+
+        public bool Equals(SessionId other) => other.sessionId == sessionId;
 
         public static bool operator ==(SessionId a, SessionId b) => a.sessionId == b.sessionId;
 
@@ -37,7 +39,7 @@ public SessionId(string sessionId)
         public override string ToString() => $"session-{sessionId}";
     }
 
-    public struct MessageId
+    public struct MessageId : IEquatable<MessageId>
     {
         public readonly string sessionId;
         public readonly int id;
@@ -54,7 +56,9 @@ public MessageId(string sessionId, int id)
 
         public override int GetHashCode() => (sessionId?.GetHashCode() ?? 0) ^ id.GetHashCode();
 
-        public override bool Equals(object obj) => (obj is MessageId) ? ((MessageId)obj).sessionId == sessionId && ((MessageId)obj).id == id : false;
+        public override bool Equals(object obj) => obj is MessageId other && Equals(other);
+
+        public bool Equals(MessageId other) => other.sessionId == sessionId && other.id == id;
     }
 
     internal class DotnetObjectId
diff --git a/src/tasks/WasmAppBuilder/PInvokeTableGenerator.cs b/src/tasks/WasmAppBuilder/PInvokeTableGenerator.cs
index 9526a602876f28..34b42e2db3ad63 100644
--- a/src/tasks/WasmAppBuilder/PInvokeTableGenerator.cs
+++ b/src/tasks/WasmAppBuilder/PInvokeTableGenerator.cs
@@ -478,7 +478,9 @@ private static bool IsBlittable (Type type)
     private static void Error (string msg) => throw new LogAsErrorException(msg);
 }
 
+#pragma warning disable CA1067
 internal sealed class PInvoke : IEquatable<PInvoke>
+#pragma warning restore CA1067
 {
     public PInvoke(string entryPoint, string module, MethodInfo method)
     {

From 6cf765e72719a73d43c37e8d1ddfcb54a0e89564 Mon Sep 17 00:00:00 2001
From: imhameed <imhameed@microsoft.com>
Date: Mon, 24 Jan 2022 10:28:49 -0500
Subject: [PATCH 033/161] [mono] Temporarily disable two tests that fail on
 arm64 LLVM FullAOT. (#64180)

---
 src/tests/issues.targets | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index edf95e8c106f62..d6aa159fba256f 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -2805,6 +2805,13 @@
         <ExcludeList Include="$(XunitTestBinBase)/Interop/DisabledRuntimeMarshalling/DisabledRuntimeMarshalling_Disabled_NativeAssemblyEnabled/**">
             <Issue>This test includes an intentionally-invalid UnmanagedCallersOnly method. Invalid UnmanagedCallersOnly methods cause failures at AOT-time.</Issue>
         </ExcludeList>
+
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/Arm/ArmBase/Yield_*/**">
+            <Issue>https://github.com/dotnet/runtime/issues/64179</Issue>
+        </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/SIMD/VectorExp_*/**">
+            <Issue>https://github.com/dotnet/runtime/issues/64179</Issue>
+        </ExcludeList>
     </ItemGroup>
 
     <ItemGroup Condition="'$(RuntimeFlavor)' == 'mono' and ('$(RuntimeVariant)' == 'llvmfullaot' or '$(RuntimeVariant)' == 'llvmaot')">

From eb8a502a0cac4733cdfb30e39288a808f51851ba Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Mon, 24 Jan 2022 10:33:04 -0500
Subject: [PATCH 034/161] Delete stale reference in System.Drawing.Primitives
 (#64202)

---
 .../src/System.Drawing.Primitives.csproj                         | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/libraries/System.Drawing.Primitives/src/System.Drawing.Primitives.csproj b/src/libraries/System.Drawing.Primitives/src/System.Drawing.Primitives.csproj
index 162b5d563a72d3..e8328af20cde96 100644
--- a/src/libraries/System.Drawing.Primitives/src/System.Drawing.Primitives.csproj
+++ b/src/libraries/System.Drawing.Primitives/src/System.Drawing.Primitives.csproj
@@ -36,7 +36,6 @@
              Link="Common\Interop\Windows\User32\Interop.Win32SystemColors.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Win32.SystemEvents\src\Microsoft.Win32.SystemEvents.csproj" />
     <Reference Include="System.Collections" />
     <Reference Include="System.ComponentModel.Primitives" />
     <Reference Include="System.Numerics.Vectors" />

From d99fa6789ad213df87358b0bd6fbffd9e0c31371 Mon Sep 17 00:00:00 2001
From: Eric Erhardt <eric.erhardt@microsoft.com>
Date: Mon, 24 Jan 2022 10:42:15 -0600
Subject: [PATCH 035/161] Respond to feedback in
 GenerateMultiTargetRoslynComponentTargetsFile (#63943)

* Respond to feedback in GenerateMultiTargetRoslynComponentTargetsFile

Two small follow up changes from #58446

- Fix a type-o that breaks incremental build. Forgot to use MSBuild property syntax
- Instead of having the infrastructure hard-code removing 'Abstractions', packages can set their own Disable source gen property name.

* PR feedback
---
 docs/coding-guidelines/libraries-packaging.md              | 7 +++++++
 eng/packaging.targets                                      | 7 +++----
 .../src/Microsoft.Extensions.Logging.Abstractions.csproj   | 1 +
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/docs/coding-guidelines/libraries-packaging.md b/docs/coding-guidelines/libraries-packaging.md
index 9e07a0683fd8d0..66909e4df855cf 100644
--- a/docs/coding-guidelines/libraries-packaging.md
+++ b/docs/coding-guidelines/libraries-packaging.md
@@ -86,5 +86,12 @@ In the analyzer project make sure to do the following. Ensure it only targets `n
   </PropertyGroup>
 ```
 
+In order to mitigate design-time/build-time performance issues with source generators, we generate build logic to allow the end user to disable the source generator from the package. By default, the MSBuild property an end user can set is named `Disable{PackageId}SourceGenerator`. If a package needs a custom property name, this can be overriden by setting the following property in the project that produces the package
+```xml
+  <PropertyGroup> 
+    <DisableSourceGeneratorPropertyName>CustomPropertyName</DisableSourceGeneratorPropertyName> 
+  </PropertyGroup>
+```
+
 ### .NETFramework RID specific assets
 When targeting .NETFramework, RID specific assets are automatically added to the package if the project contains other compatible RID specific assets, mainly `netstandard2.0-windows`.
diff --git a/eng/packaging.targets b/eng/packaging.targets
index 667837fbff1067..c305c64dd94090 100644
--- a/eng/packaging.targets
+++ b/eng/packaging.targets
@@ -162,19 +162,18 @@
   </Target>
 
   <Target Name="GenerateMultiTargetRoslynComponentTargetsFile"
-          Inputs="$(MSBuildProjectFullPath);_MultiTargetRoslynComponentTargetsTemplate"
+          Inputs="$(MSBuildProjectFullPath);$(_MultiTargetRoslynComponentTargetsTemplate)"
           Outputs="$(MultiTargetRoslynComponentTargetsFileIntermediatePath)">
     <PropertyGroup>
       <_MultiTargetRoslynComponentTargetPrefix>$(PackageId.Replace('.', '_'))</_MultiTargetRoslynComponentTargetPrefix>
-      <_MultiTargetRoslynComponentDisableSourceGeneratorPropertyName>Disable$(PackageId.Replace('.', ''))SourceGenerator</_MultiTargetRoslynComponentDisableSourceGeneratorPropertyName>
-      <_MultiTargetRoslynComponentDisableSourceGeneratorPropertyName>$(_MultiTargetRoslynComponentDisableSourceGeneratorPropertyName.Replace('Abstractions', ''))</_MultiTargetRoslynComponentDisableSourceGeneratorPropertyName>
+      <DisableSourceGeneratorPropertyName Condition="'$(DisableSourceGeneratorPropertyName)' == ''">Disable$(PackageId.Replace('.', ''))SourceGenerator</DisableSourceGeneratorPropertyName>
     </PropertyGroup>
 
     <WriteLinesToFile File="$(MultiTargetRoslynComponentTargetsFileIntermediatePath)"
                       Lines="$([System.IO.File]::ReadAllText('$(_MultiTargetRoslynComponentTargetsTemplate)')
                                                  .Replace('{TargetPrefix}', '$(_MultiTargetRoslynComponentTargetPrefix)')
                                                  .Replace('{NuGetPackageId}', '$(PackageId)')
-                                                 .Replace('{DisableSourceGeneratorPropertyName}', '$(_MultiTargetRoslynComponentDisableSourceGeneratorPropertyName)'))"
+                                                 .Replace('{DisableSourceGeneratorPropertyName}', '$(DisableSourceGeneratorPropertyName)'))"
                       Overwrite="true" />
   </Target>
 
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj
index 8ca2bab854730e..eb95f66e4f5a36 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj
@@ -18,6 +18,7 @@ Microsoft.Extensions.Logging.LogLevel
 Microsoft.Extensions.Logging.Logger&lt;T&gt;
 Microsoft.Extensions.Logging.LoggerMessage
 Microsoft.Extensions.Logging.Abstractions.NullLogger</PackageDescription>
+    <DisableSourceGeneratorPropertyName>DisableMicrosoftExtensionsLoggingSourceGenerator</DisableSourceGeneratorPropertyName>
   </PropertyGroup>
 
   <ItemGroup>

From 2713e11deefb1757644dc2366c35379dd95f7b08 Mon Sep 17 00:00:00 2001
From: Kevin Jones <kevin@vcsjones.com>
Date: Mon, 24 Jan 2022 12:52:58 -0500
Subject: [PATCH 036/161] Use the static HashData(Stream) method in more places

---
 .../AsymmetricAlgorithmHelpers.Hash.cs        | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/libraries/Common/src/Internal/Cryptography/AsymmetricAlgorithmHelpers.Hash.cs b/src/libraries/Common/src/Internal/Cryptography/AsymmetricAlgorithmHelpers.Hash.cs
index dc3e3426596e99..a4c41cfbcac620 100644
--- a/src/libraries/Common/src/Internal/Cryptography/AsymmetricAlgorithmHelpers.Hash.cs
+++ b/src/libraries/Common/src/Internal/Cryptography/AsymmetricAlgorithmHelpers.Hash.cs
@@ -34,16 +34,21 @@ public static byte[] HashData(byte[] data, int offset, int count, HashAlgorithmN
                 throw new CryptographicException(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithm.Name);
         }
 
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5350", Justification = "SHA1 is used when the user asks for it.")]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5351", Justification = "MD5 is used when the user asks for it.")]
         public static byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm)
         {
             // The classes that call us are sealed and their base class has checked this already.
             Debug.Assert(data != null);
             Debug.Assert(!string.IsNullOrEmpty(hashAlgorithm.Name));
 
-            using (HashAlgorithm hasher = GetHashAlgorithm(hashAlgorithm))
-            {
-                return hasher.ComputeHash(data);
-            }
+            return
+                hashAlgorithm == HashAlgorithmName.SHA256 ? SHA256.HashData(data) :
+                hashAlgorithm == HashAlgorithmName.SHA1 ? SHA1.HashData(data) :
+                hashAlgorithm == HashAlgorithmName.SHA512 ? SHA512.HashData(data) :
+                hashAlgorithm == HashAlgorithmName.SHA384 ? SHA384.HashData(data) :
+                hashAlgorithm == HashAlgorithmName.MD5 ? MD5.HashData(data) :
+                throw new CryptographicException(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithm.Name);
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5350", Justification = "SHA1 is used when the user asks for it.")]
@@ -61,15 +66,5 @@ public static bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination
                 hashAlgorithm == HashAlgorithmName.MD5 ? MD5.TryHashData(source, destination, out bytesWritten) :
                 throw new CryptographicException(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithm.Name);
         }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5350", Justification = "SHA1 is used when the user asks for it.")]
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA5351", Justification = "MD5 is used when the user asks for it.")]
-        private static HashAlgorithm GetHashAlgorithm(HashAlgorithmName hashAlgorithmName) =>
-            hashAlgorithmName == HashAlgorithmName.SHA256 ? SHA256.Create() :
-            hashAlgorithmName == HashAlgorithmName.SHA1 ? SHA1.Create() :
-            hashAlgorithmName == HashAlgorithmName.SHA512 ? SHA512.Create() :
-            hashAlgorithmName == HashAlgorithmName.SHA384 ? SHA384.Create() :
-            hashAlgorithmName == HashAlgorithmName.MD5 ? MD5.Create() :
-            throw new CryptographicException(SR.Cryptography_UnknownHashAlgorithm, hashAlgorithmName.Name);
     }
 }

From 02eaf5f1bb8f8eac1c7528a1b223087a1b76a7d4 Mon Sep 17 00:00:00 2001
From: Gleb Balykov <g.balykov@samsung.com>
Date: Mon, 24 Jan 2022 21:21:44 +0300
Subject: [PATCH 037/161] Add executable bit to tizen sh files (#64216)

---
 eng/common/cross/arm/tizen-build-rootfs.sh | 0
 eng/common/cross/arm/tizen-fetch.sh        | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 eng/common/cross/arm/tizen-build-rootfs.sh
 mode change 100644 => 100755 eng/common/cross/arm/tizen-fetch.sh

diff --git a/eng/common/cross/arm/tizen-build-rootfs.sh b/eng/common/cross/arm/tizen-build-rootfs.sh
old mode 100644
new mode 100755
diff --git a/eng/common/cross/arm/tizen-fetch.sh b/eng/common/cross/arm/tizen-fetch.sh
old mode 100644
new mode 100755

From b923e9929d7a7e723e21817cd2f307aa44e3f20b Mon Sep 17 00:00:00 2001
From: Carlos Sanchez <1175054+carlossanlop@users.noreply.github.com>
Date: Mon, 24 Jan 2022 10:40:18 -0800
Subject: [PATCH 038/161] Bump Intellisensense package version to latest from
 `dotnet7-transport` (#63352)

---
 NuGet.config       | 1 +
 eng/Versions.props | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/NuGet.config b/NuGet.config
index f74e0c4a70248a..01da6689762612 100644
--- a/NuGet.config
+++ b/NuGet.config
@@ -15,6 +15,7 @@
     <add key="dotnet-public" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public/nuget/v3/index.json" />
     <add key="dotnet-tools" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json" />
     <add key="dotnet-eng" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json" />
+    <!-- TODO: Remove dotnet7 feeds when dependencies publish into dotnet8 feeds: https://github.com/dotnet/runtime/issues/63375. -->
     <add key="dotnet7" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet7/nuget/v3/index.json" />
     <add key="dotnet7-transport" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet7-transport/nuget/v3/index.json" />
     <!-- TODO: Remove dotnet6 feeds when dependencies publish into dotnet7 feeds: https://github.com/dotnet/runtime/issues/57716. -->
diff --git a/eng/Versions.props b/eng/Versions.props
index 85e7bdd4cdc822..6484ee772cec7c 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -114,7 +114,7 @@
     <SystemRuntimeInteropServicesVersion>4.3.0</SystemRuntimeInteropServicesVersion>
     <SystemRuntimeInteropServicesRuntimeInformationVersion>4.3.0</SystemRuntimeInteropServicesRuntimeInformationVersion>
     <SystemRuntimeSerializationPrimitivesVersion>4.3.0</SystemRuntimeSerializationPrimitivesVersion>
-    <SystemSecurityAccessControlVersion>6.0.0-rc.2.21454.1</SystemSecurityAccessControlVersion>
+    <SystemSecurityAccessControlVersion>6.0.0</SystemSecurityAccessControlVersion>
     <SystemSecurityCryptographyAlgorithmsVersion>4.3.1</SystemSecurityCryptographyAlgorithmsVersion>
     <SystemSecurityCryptographyCngVersion>5.0.0</SystemSecurityCryptographyCngVersion>
     <SystemSecurityCryptographyOpenSslVersion>5.0.0</SystemSecurityCryptographyOpenSslVersion>
@@ -175,7 +175,7 @@
     <SdkVersionForWorkloadTesting>7.0.100-alpha.1.21528.1</SdkVersionForWorkloadTesting>
     <CompilerPlatformTestingVersion>1.1.1-beta1.21467.5</CompilerPlatformTestingVersion>
     <!-- Docs -->
-    <MicrosoftPrivateIntellisenseVersion>6.0.0-preview-20211019.1</MicrosoftPrivateIntellisenseVersion>
+    <MicrosoftPrivateIntellisenseVersion>6.0.0-preview-20220104.1</MicrosoftPrivateIntellisenseVersion>
     <!-- ILLink -->
     <MicrosoftNETILLinkTasksVersion>7.0.100-1.22063.2</MicrosoftNETILLinkTasksVersion>
     <MicrosoftNETILLinkAnalyzerPackageVersion>$(MicrosoftNETILLinkTasksVersion)</MicrosoftNETILLinkAnalyzerPackageVersion>

From 0ef4f467482c1404b01d1f6ada0b2968ac219fc5 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 24 Jan 2022 11:01:19 -0800
Subject: [PATCH 039/161] Ensure that we aren't accidentally generating
 instructions for unsupported ISAs (#64140)

* Assert that the ISA of the set intrinsic ID is supported

* Ensure gtNewSimdCmpOpAllNode and gtNewSimdCmpOpAnyNode don't generate AVX2 instructions when not supported

* Ensure codegen for Vector128.Dot when SSSE3 is disabled is correct

* Update src/coreclr/jit/hwintrinsiccodegenarm64.cpp

Co-authored-by: Jan Kotas <jkotas@microsoft.com>

* Ensure Vector256.Sum has a check for AVX2

Co-authored-by: Jan Kotas <jkotas@microsoft.com>
---
 src/coreclr/jit/gentree.cpp                 | 61 ++++++++++++++-------
 src/coreclr/jit/hwintrinsiccodegenarm64.cpp |  3 +
 src/coreclr/jit/hwintrinsiccodegenxarch.cpp |  3 +
 src/coreclr/jit/hwintrinsicxarch.cpp        | 25 +++++----
 src/coreclr/jit/lowerxarch.cpp              |  2 +-
 5 files changed, 64 insertions(+), 30 deletions(-)

diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index 678a2a60409db7..8c9450cfbf5649 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -19294,20 +19294,22 @@ GenTree* Compiler::gtNewSimdCmpOpAllNode(genTreeOps  op,
 
     NamedIntrinsic intrinsic = NI_Illegal;
 
-#if defined(TARGET_XARCH)
-    if (simdSize == 32)
-    {
-        assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
-        assert(varTypeIsFloating(simdBaseType) || compIsaSupportedDebugOnly(InstructionSet_AVX2));
-    }
-#endif // TARGET_XARCH
-
     switch (op)
     {
 #if defined(TARGET_XARCH)
         case GT_EQ:
         {
-            intrinsic = (simdSize == 32) ? NI_Vector256_op_Equality : NI_Vector128_op_Equality;
+            if (simdSize == 32)
+            {
+                assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
+                assert(varTypeIsFloating(simdBaseType) || compIsaSupportedDebugOnly(InstructionSet_AVX2));
+
+                intrinsic = NI_Vector256_op_Equality;
+            }
+            else
+            {
+                intrinsic = NI_Vector128_op_Equality;
+            }
             break;
         }
 
@@ -19323,6 +19325,12 @@ GenTree* Compiler::gtNewSimdCmpOpAllNode(genTreeOps  op,
 
             if (simdSize == 32)
             {
+                // TODO-XArch-CQ: It's a non-trivial amount of work to support these
+                // for floating-point while only utilizing AVX. It would require, among
+                // other things, inverting the comparison and potentially support for a
+                // new Avx.TestNotZ intrinsic to ensure the codegen remains efficient.
+                assert(compIsaSupportedDebugOnly(InstructionSet_AVX2));
+
                 intrinsic     = NI_Vector256_op_Equality;
                 getAllBitsSet = NI_Vector256_get_AllBitsSet;
             }
@@ -19433,14 +19441,6 @@ GenTree* Compiler::gtNewSimdCmpOpAnyNode(genTreeOps  op,
 
     NamedIntrinsic intrinsic = NI_Illegal;
 
-#if defined(TARGET_XARCH)
-    if (simdSize == 32)
-    {
-        assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
-        assert(varTypeIsFloating(simdBaseType) || compIsaSupportedDebugOnly(InstructionSet_AVX2));
-    }
-#endif // TARGET_XARCH
-
     switch (op)
     {
 #if defined(TARGET_XARCH)
@@ -19453,7 +19453,20 @@ GenTree* Compiler::gtNewSimdCmpOpAnyNode(genTreeOps  op,
             // We want to generate a comparison along the lines of
             // GT_XX(op1, op2).As<T, TInteger>() != Vector128<TInteger>.Zero
 
-            intrinsic = (simdSize == 32) ? NI_Vector256_op_Inequality : NI_Vector128_op_Inequality;
+            if (simdSize == 32)
+            {
+                // TODO-XArch-CQ: It's a non-trivial amount of work to support these
+                // for floating-point while only utilizing AVX. It would require, among
+                // other things, inverting the comparison and potentially support for a
+                // new Avx.TestNotZ intrinsic to ensure the codegen remains efficient.
+                assert(compIsaSupportedDebugOnly(InstructionSet_AVX2));
+
+                intrinsic = NI_Vector256_op_Inequality;
+            }
+            else
+            {
+                intrinsic = NI_Vector128_op_Inequality;
+            }
 
             op1 = gtNewSimdCmpOpNode(op, simdType, op1, op2, simdBaseJitType, simdSize,
                                      /* isSimdAsHWIntrinsic */ false);
@@ -19475,7 +19488,17 @@ GenTree* Compiler::gtNewSimdCmpOpAnyNode(genTreeOps  op,
 
         case GT_NE:
         {
-            intrinsic = (simdSize == 32) ? NI_Vector256_op_Inequality : NI_Vector128_op_Inequality;
+            if (simdSize == 32)
+            {
+                assert(compIsaSupportedDebugOnly(InstructionSet_AVX));
+                assert(varTypeIsFloating(simdBaseType) || compIsaSupportedDebugOnly(InstructionSet_AVX2));
+
+                intrinsic = NI_Vector256_op_Inequality;
+            }
+            else
+            {
+                intrinsic = NI_Vector128_op_Inequality;
+            }
             break;
         }
 #elif defined(TARGET_ARM64)
diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp
index e4b9a1326680c0..6dfe48047c094e 100644
--- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp
+++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp
@@ -206,6 +206,9 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node)
 {
     const HWIntrinsic intrin(node);
 
+    // We need to validate that other phases of the compiler haven't introduced unsupported intrinsics
+    assert(compiler->compIsaSupportedDebugOnly(HWIntrinsicInfo::lookupIsa(intrin.id)));
+
     regNumber targetReg = node->GetRegNum();
 
     regNumber op1Reg = REG_NA;
diff --git a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp
index d6490c59b2e360..10c8dcaedb197a 100644
--- a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp
+++ b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp
@@ -86,6 +86,9 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node)
     HWIntrinsicCategory    category    = HWIntrinsicInfo::lookupCategory(intrinsicId);
     size_t                 numArgs     = node->GetOperandCount();
 
+    // We need to validate that other phases of the compiler haven't introduced unsupported intrinsics
+    assert(compiler->compIsaSupportedDebugOnly(isa));
+
     int ival = HWIntrinsicInfo::lookupIval(intrinsicId, compiler->compOpportunisticallyDependsOn(InstructionSet_AVX));
 
     assert(HWIntrinsicInfo::RequiresCodegen(intrinsicId));
diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp
index f1b84825f21762..aec1be705f3db8 100644
--- a/src/coreclr/jit/hwintrinsicxarch.cpp
+++ b/src/coreclr/jit/hwintrinsicxarch.cpp
@@ -1024,7 +1024,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1287,7 +1287,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1305,7 +1305,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1339,7 +1339,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1357,7 +1357,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1391,7 +1391,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1409,7 +1409,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1443,7 +1443,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -1461,7 +1461,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if ((simdSize != 32) || varTypeIsFloating(simdBaseType) || compExactlyDependsOn(InstructionSet_AVX2))
+            if ((simdSize != 32) || compExactlyDependsOn(InstructionSet_AVX2))
             {
                 var_types simdType = getSIMDTypeForSize(simdSize);
 
@@ -2024,7 +2024,12 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
             assert(sig->numArgs == 1);
             var_types simdType = getSIMDTypeForSize(simdSize);
 
-            if (varTypeIsFloating(simdBaseType))
+            if ((simdSize == 32) && !compOpportunisticallyDependsOn(InstructionSet_AVX2))
+            {
+                // Vector256 for integer types requires AVX2
+                break;
+            }
+            else if (varTypeIsFloating(simdBaseType))
             {
                 if (!compOpportunisticallyDependsOn(InstructionSet_SSE3))
                 {
diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp
index a6b0ceb91ba955..1331644a0a992b 100644
--- a/src/coreclr/jit/lowerxarch.cpp
+++ b/src/coreclr/jit/lowerxarch.cpp
@@ -3456,7 +3456,7 @@ void Lowering::LowerHWIntrinsicDot(GenTreeHWIntrinsic* node)
                     //   e6, e7, e4, e5 | e2, e3, e0, e1
                     //   e7, e6, e5, e4 | e3, e2, e1, e0
 
-                    shuffleConst = 0x4D;
+                    shuffleConst = 0x4E;
                     break;
                 }
 

From 29cc2a2c23ce15469575a0b25c8b8b453a1d975f Mon Sep 17 00:00:00 2001
From: Viktor Hofer <viktor.hofer@microsoft.com>
Date: Mon, 24 Jan 2022 20:32:43 +0100
Subject: [PATCH 040/161] Don't reference .NETFramework shims in libraries
 product or test composition (#64193)

* Don't reference .NETFramework shims

Stop referencing .NETFramework shims in libraries ref or source projects as those are supplementary and shouldn't impact the product composition.
---
 src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj      | 1 -
 .../System.Formats.Cbor/src/System.Formats.Cbor.csproj          | 1 -
 src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs | 2 --
 .../tests/FunctionalTests/SocketDuplicationTests.cs             | 1 -
 4 files changed, 5 deletions(-)

diff --git a/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj b/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj
index 9cc4d09bf298b6..2005ee7715654e 100644
--- a/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj
+++ b/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj
@@ -176,7 +176,6 @@ System.Data.Odbc.OdbcTransaction</PackageDescription>
     <Reference Include="System.Threading.Thread" />
     <Reference Include="System.Threading.ThreadPool" />
     <Reference Include="System.Threading.Timer" />
-    <Reference Include="System.Transactions" />
     <Reference Include="System.Transactions.Local" />
     <Reference Include="System.Xml.ReaderWriter" />
   </ItemGroup>
diff --git a/src/libraries/System.Formats.Cbor/src/System.Formats.Cbor.csproj b/src/libraries/System.Formats.Cbor/src/System.Formats.Cbor.csproj
index 29b98e85415777..c4783ca29c1670 100644
--- a/src/libraries/System.Formats.Cbor/src/System.Formats.Cbor.csproj
+++ b/src/libraries/System.Formats.Cbor/src/System.Formats.Cbor.csproj
@@ -49,7 +49,6 @@ System.Formats.Cbor.CborWriter</PackageDescription>
   </ItemGroup>
     
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <Reference Include="System" />
     <Reference Include="System.Buffers" />
     <Reference Include="System.Collections" />
     <Reference Include="System.Memory" />
diff --git a/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs b/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs
index c4d34c320668ef..d4965d1dbedb60 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/EncryptDecrypt.cs
@@ -3,9 +3,7 @@
 
 using Microsoft.DotNet.XUnitExtensions;
 using System.Diagnostics;
-using System.Diagnostics.Eventing.Reader;
 using System.Security;
-using System.ServiceProcess;
 using Xunit;
 using Xunit.Abstractions;
 
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketDuplicationTests.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketDuplicationTests.cs
index 8e257352fd18c3..b59c5ebd92a33e 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketDuplicationTests.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketDuplicationTests.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
-using System.Drawing.Drawing2D;
 using System.IO;
 using System.IO.Pipes;
 using System.Runtime.Serialization.Formatters.Binary;

From 1c509934921d6a8b52cc9cb48e983b56da759580 Mon Sep 17 00:00:00 2001
From: Mitchell Hwang <16830051+mdh1418@users.noreply.github.com>
Date: Mon, 24 Jan 2022 15:06:56 -0500
Subject: [PATCH 041/161] [Android][libs] Enable Internal.Console.Write in
 System.Private.CoreLib (#63949)

* [Android][libs] Enable Internal.Console.Write in System.Private.CoreLib

* [docs] Add debugging System.Private.CoreLib Internal.Console.Write

* Elaborate on debugging corelib log

* Address feedback
---
 .../debugging/libraries/debugging-corelib.md  |  7 ++++++
 .../src/Internal/Console.Android.cs           | 24 +++++++++++++++++++
 .../System.Private.CoreLib.Shared.projitems   |  9 ++++++-
 3 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 docs/workflow/debugging/libraries/debugging-corelib.md
 create mode 100644 src/libraries/System.Private.CoreLib/src/Internal/Console.Android.cs

diff --git a/docs/workflow/debugging/libraries/debugging-corelib.md b/docs/workflow/debugging/libraries/debugging-corelib.md
new file mode 100644
index 00000000000000..9dd817d5bf7ff7
--- /dev/null
+++ b/docs/workflow/debugging/libraries/debugging-corelib.md
@@ -0,0 +1,7 @@
+Debugging System.Private.CoreLib
+==========================
+
+`System.Console.Write`/`System.Console.WriteLine` cannot be used in `System.Private.CoreLib`. Instead, use `Internal.Console.Write` to add temporary logging for printf-style debugging.
+
+### Android
+The logs can be found through the generated Android Debug Bridge log or viewed directly through ADB logcat.
diff --git a/src/libraries/System.Private.CoreLib/src/Internal/Console.Android.cs b/src/libraries/System.Private.CoreLib/src/Internal/Console.Android.cs
new file mode 100644
index 00000000000000..a1f427d0af7f11
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/Internal/Console.Android.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Internal
+{
+    public static partial class Console
+    {
+        public static unsafe void Write(string s)
+        {
+            Interop.Logcat.AndroidLogPrint(Interop.Logcat.LogLevel.Debug, "DOTNET", s ?? string.Empty);
+        }
+
+        public static partial class Error
+        {
+            public static unsafe void Write(string s)
+            {
+                Interop.Logcat.AndroidLogPrint(Interop.Logcat.LogLevel.Error, "DOTNET", s ?? string.Empty);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index ebbc2d77b6a93a..d5ce32af96642c 100644
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -2120,7 +2120,14 @@
     <Compile Include="$(CommonPath)System\IO\PathInternal.Unix.cs">
       <Link>Common\System\IO\PathInternal.Unix.cs</Link>
     </Compile>
-    <Compile Include="$(MSBuildThisFileDirectory)Internal\Console.Unix.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Internal\Console.Unix.cs" Condition="'$(TargetsAndroid)' != 'true'" />
+    <Compile Include="$(MSBuildThisFileDirectory)Internal\Console.Android.cs" Condition="'$(TargetsAndroid)' == 'true'" />
+    <Compile Include="$(CommonPath)Interop\Android\Interop.Logcat.cs" Condition="'$(TargetsAndroid)' == 'true'">
+      <Link>Common\Interop\Android\Interop.Logcat.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)Interop\Android\Interop.Libraries.cs" Condition="'$(TargetsAndroid)' == 'true'">
+      <Link>Common\Interop\Android\Interop.Libraries.cs</Link>
+    </Compile>
     <Compile Include="$(MSBuildThisFileDirectory)Microsoft\Win32\SafeHandles\SafeFileHandle.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\AppDomain.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Buffer.Unix.cs" />

From ae755ab3c7f838f7dccd2a4c2d5934a9d7d82c69 Mon Sep 17 00:00:00 2001
From: Fan Yang <52458914+fanyang-mono@users.noreply.github.com>
Date: Mon, 24 Jan 2022 15:10:22 -0500
Subject: [PATCH 042/161] Install v8 and Prebuild wasm (#64100)

---
 .devcontainer/Dockerfile                 | 9 +++++++++
 .devcontainer/scripts/onCreateCommand.sh | 5 +++++
 2 files changed, 14 insertions(+)

diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index 31ff731b029117..2634a9528f1eea 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -10,3 +10,12 @@ RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
         build-essential python curl git lldb-6.0 liblldb-6.0-dev \
         libunwind8 libunwind8-dev gettext libicu-dev liblttng-ust-dev \
         libssl-dev libnuma-dev libkrb5-dev zlib1g-dev ninja-build
+
+# Install V8 Engine
+SHELL ["/bin/bash", "-c"]
+
+RUN curl -sSL "https://netcorenativeassets.blob.core.windows.net/resource-packages/external/linux/chromium-v8/v8-linux64-rel-8.5.183.zip" -o ./v8.zip \
+    && unzip ./v8.zip -d /usr/local/v8 \
+    && echo $'#!/usr/bin/env bash\n\
+"/usr/local/v8/d8" --snapshot_blob="/usr/local/v8/snapshot_blob.bin" "$@"\n' > /usr/local/bin/v8 \
+    && chmod +x /usr/local/bin/v8
\ No newline at end of file
diff --git a/.devcontainer/scripts/onCreateCommand.sh b/.devcontainer/scripts/onCreateCommand.sh
index faf7cb08d1afae..9a7e6718ba32d4 100755
--- a/.devcontainer/scripts/onCreateCommand.sh
+++ b/.devcontainer/scripts/onCreateCommand.sh
@@ -7,5 +7,10 @@ set -e
 # restore libs tests so that the project is ready to be loaded by OmniSharp
 ./build.sh libs.tests -restore
 
+# prebuild for WASM, so it is ready for wasm development
+make -C src/mono/wasm provision-wasm
+export EMSDK_PATH=$PWD/src/mono/wasm/emsdk
+./build.sh mono+libs -os Browser -c release
+
 # save the commit hash of the currently built assemblies, so developers know which version was built
 git rev-parse HEAD > ./artifacts/prebuild.sha

From df69293bdbe75bf5903583c472fcd257119dbda4 Mon Sep 17 00:00:00 2001
From: Jo Shields <directhex@apebox.org>
Date: Mon, 24 Jan 2022 16:29:57 -0500
Subject: [PATCH 043/161] Port Mono to Raspberry Pi, ship as new linux-armv6
 RID (#62594)

* Initial ARMv6 arch addition. Builds mono runtime, not CoreCLR (Mono already supports the CPU arch subset used by Raspberry Pi, whilst porting CoreCLR to e.g. VFPv2 would be major work)
* Build small clr subset on ARMv6, it's needed for SDK and we want to check it works
---
 Directory.Build.props                         |  1 +
 eng/Subsets.props                             |  2 +-
 eng/build.sh                                  |  6 +--
 eng/native/build-commons.sh                   |  6 ++-
 eng/native/configurecompiler.cmake            | 19 +++++++++
 eng/native/configureplatform.cmake            | 13 ++++++
 eng/native/configuretools.cmake               |  4 +-
 eng/native/functions.cmake                    |  6 ++-
 eng/native/init-os-and-arch.sh                |  4 ++
 eng/native/tryrun.cmake                       |  6 +--
 eng/pipelines/common/platform-matrix.yml      | 25 ++++++++++++
 .../libraries/helix-queues-setup.yml          |  5 +++
 eng/pipelines/runtime-staging.yml             | 40 +++++++++++++++++++
 eng/targetingpacks.targets                    |  4 +-
 src/coreclr/inc/volatile.h                    |  5 ++-
 src/coreclr/jit/CMakeLists.txt                | 20 +++++++++-
 src/coreclr/pal/inc/unixasmmacros.inc         |  2 +
 src/coreclr/pal/inc/unixasmmacrosarm.inc      |  4 ++
 src/coreclr/pal/src/CMakeLists.txt            |  3 ++
 .../src/arch/arm/callsignalhandlerwrapper.S   |  2 +
 src/coreclr/pal/src/arch/arm/context2.S       |  2 +
 src/coreclr/pal/src/arch/arm/debugbreak.S     |  2 +
 .../pal/src/arch/arm/exceptionhelper.S        |  2 +
 src/coreclr/pal/src/libunwind/CMakeLists.txt  | 11 ++++-
 .../pal/src/libunwind/src/CMakeLists.txt      | 10 +++++
 .../pkg/projects/netcoreappRIDs.props         |  3 ++
 .../src/runtime.compatibility.json            | 16 +++++++-
 .../src/runtime.json                          | 13 +++++-
 .../src/runtimeGroups.props                   |  4 +-
 .../Runtime/InteropServices/Architecture.cs   |  3 +-
 .../RuntimeInformation.ProcessArchitecture.cs |  2 +
 .../tests/CheckArchitectureTests.cs           |  4 ++
 .../System.Runtime/ref/System.Runtime.cs      |  1 +
 src/libraries/externals.csproj                |  2 +-
 src/libraries/tests.proj                      |  2 +-
 src/mono/CMakeLists.txt                       | 13 +++++-
 .../System.Private.CoreLib.csproj             |  6 ++-
 src/mono/mono.proj                            | 14 ++++++-
 .../corehost/fxr/standalone/CMakeLists.txt    |  4 ++
 src/native/corehost/hostmisc/utils.cpp        |  2 +
 .../corehost/test/nativehost/CMakeLists.txt   |  4 ++
 src/native/eventpipe/ep-event-source.c        |  2 +
 .../System.Native/pal_runtimeinformation.h    |  3 +-
 43 files changed, 272 insertions(+), 30 deletions(-)

diff --git a/Directory.Build.props b/Directory.Build.props
index e9e6fc4e362346..d862ee091fe81b 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -29,6 +29,7 @@
     <_hostArch>$([System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture.ToString().ToLowerInvariant)</_hostArch>
     <BuildArchitecture Condition="'$(BuildArchitecture)' == ''">$(_hostArch)</BuildArchitecture>
     <TargetArchitecture Condition="'$(TargetArchitecture)' == '' and '$(_hostArch)' == 'arm'">arm</TargetArchitecture>
+    <TargetArchitecture Condition="'$(TargetArchitecture)' == '' and '$(_hostArch)' == 'armv6'">armv6</TargetArchitecture>
     <TargetArchitecture Condition="'$(TargetArchitecture)' == '' and '$(_hostArch)' == 'armel'">armel</TargetArchitecture>
     <TargetArchitecture Condition="'$(TargetArchitecture)' == '' and '$(_hostArch)' == 'arm64'">arm64</TargetArchitecture>
     <TargetArchitecture Condition="'$(TargetArchitecture)' == '' and '$(_hostArch)' == 'loongarch64'">loongarch64</TargetArchitecture>
diff --git a/eng/Subsets.props b/eng/Subsets.props
index 5ce54174451364..fbe6f9712686ed 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -27,7 +27,7 @@
        flavor is used to decide when to build the hosts and installers. -->
   <PropertyGroup>
     <PrimaryRuntimeFlavor>CoreCLR</PrimaryRuntimeFlavor>
-    <PrimaryRuntimeFlavor Condition="'$(TargetArchitecture)' == 's390x'">Mono</PrimaryRuntimeFlavor>
+    <PrimaryRuntimeFlavor Condition="'$(TargetArchitecture)' == 's390x' or '$(TargetArchitecture)' == 'armv6'">Mono</PrimaryRuntimeFlavor>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/eng/build.sh b/eng/build.sh
index ea8e3089e95f4d..167f8e2014182e 100755
--- a/eng/build.sh
+++ b/eng/build.sh
@@ -17,7 +17,7 @@ scriptroot="$( cd -P "$( dirname "$source" )" && pwd )"
 usage()
 {
   echo "Common settings:"
-  echo "  --arch (-a)                     Target platform: x86, x64, arm, armel, arm64, loongarch64, s390x or wasm."
+  echo "  --arch (-a)                     Target platform: x86, x64, arm, armv6, armel, arm64, loongarch64, s390x or wasm."
   echo "                                  [Default: Your machine's architecture.]"
   echo "  --binaryLog (-bl)               Output binary log."
   echo "  --cross                         Optional argument to signify cross compilation."
@@ -206,12 +206,12 @@ while [[ $# > 0 ]]; do
       fi
       passedArch="$(echo "$2" | tr "[:upper:]" "[:lower:]")"
       case "$passedArch" in
-        x64|x86|arm|armel|arm64|loongarch64|s390x|wasm)
+        x64|x86|arm|armv6|armel|arm64|loongarch64|s390x|wasm)
           arch=$passedArch
           ;;
         *)
           echo "Unsupported target architecture '$2'."
-          echo "The allowed values are x86, x64, arm, armel, arm64, loongarch64, s390x, and wasm."
+          echo "The allowed values are x86, x64, arm, armv6, armel, arm64, loongarch64, s390x, and wasm."
           exit 1
           ;;
       esac
diff --git a/eng/native/build-commons.sh b/eng/native/build-commons.sh
index 373091b13a0014..294e9832ad3105 100755
--- a/eng/native/build-commons.sh
+++ b/eng/native/build-commons.sh
@@ -197,7 +197,7 @@ usage()
     echo ""
     echo "Common Options:"
     echo ""
-    echo "BuildArch can be: -arm, -armel, -arm64, -loongarch64, -s390x, x64, x86, -wasm"
+    echo "BuildArch can be: -arm, -armv6, -armel, -arm64, -loongarch64, -s390x, x64, x86, -wasm"
     echo "BuildType can be: -debug, -checked, -release"
     echo "-os: target OS (defaults to running OS)"
     echo "-bindir: output directory (defaults to $__ProjectRoot/artifacts)"
@@ -270,6 +270,10 @@ while :; do
             __BuildArch=arm
             ;;
 
+        armv6|-armv6)
+            __BuildArch=armv6
+            ;;
+
         arm64|-arm64)
             __BuildArch=arm64
             ;;
diff --git a/eng/native/configurecompiler.cmake b/eng/native/configurecompiler.cmake
index fad1ac58d39c88..b67594cb60fb2a 100644
--- a/eng/native/configurecompiler.cmake
+++ b/eng/native/configurecompiler.cmake
@@ -213,6 +213,9 @@ elseif (CLR_CMAKE_HOST_ARCH_I386)
 elseif (CLR_CMAKE_HOST_ARCH_ARM)
   set(ARCH_HOST_NAME arm)
   add_definitions(-DHOST_ARM)
+elseif (CLR_CMAKE_HOST_ARCH_ARMV6)
+  set(ARCH_HOST_NAME armv6)
+  add_definitions(-DHOST_ARMV6)
 elseif (CLR_CMAKE_HOST_ARCH_ARM64)
   set(ARCH_HOST_NAME arm64)
   add_definitions(-DHOST_ARM64 -DHOST_64BIT)
@@ -238,6 +241,8 @@ if (CLR_CMAKE_HOST_UNIX)
       message("Detected Linux x86_64")
     elseif(CLR_CMAKE_HOST_UNIX_ARM)
       message("Detected Linux ARM")
+    elseif(CLR_CMAKE_HOST_UNIX_ARMV6)
+      message("Detected Linux ARMv6")
     elseif(CLR_CMAKE_HOST_UNIX_ARM64)
       message("Detected Linux ARM64")
     elseif(CLR_CMAKE_HOST_UNIX_LOONGARCH64)
@@ -301,6 +306,12 @@ elseif (CLR_CMAKE_TARGET_ARCH_ARM)
     set(ARCH_TARGET_NAME arm)
     add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_ARCH>>>:TARGET_ARM>)
     add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_ARCH>>>:TARGET_32BIT>)
+elseif (CLR_CMAKE_TARGET_ARCH_ARMV6)
+    set(ARCH_SOURCES_DIR arm)
+    set(ARCH_TARGET_NAME armv6)
+    add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_ARCH>>>:TARGET_ARM>)
+    add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_ARCH>>>:TARGET_ARMV6>)
+    add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_ARCH>>>:TARGET_32BIT>)
 elseif (CLR_CMAKE_TARGET_ARCH_I386)
     set(ARCH_TARGET_NAME x86)
     set(ARCH_SOURCES_DIR i386)
@@ -507,6 +518,14 @@ if(CLR_CMAKE_HOST_UNIX_ARM)
    endif(ARM_SOFTFP)
 endif(CLR_CMAKE_HOST_UNIX_ARM)
 
+if(CLR_CMAKE_HOST_UNIX_ARMV6)
+   add_compile_options(-mfpu=vfp)
+   add_definitions(-DCLR_ARM_FPU_CAPABILITY=0x0)
+   add_compile_options(-march=armv6zk)
+   add_compile_options(-mcpu=arm1176jzf-s)
+   add_compile_options(-mfloat-abi=hard)
+endif(CLR_CMAKE_HOST_UNIX_ARMV6)
+
 if(CLR_CMAKE_HOST_UNIX_X86)
   add_compile_options(-msse2)
 endif()
diff --git a/eng/native/configureplatform.cmake b/eng/native/configureplatform.cmake
index cdf33430b49f11..ecf10a8d4c39ef 100644
--- a/eng/native/configureplatform.cmake
+++ b/eng/native/configureplatform.cmake
@@ -41,6 +41,8 @@ if(CLR_CMAKE_HOST_OS STREQUAL Linux)
             set(CLR_CMAKE_HOST_UNIX_ARMV7L 1)
         elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL arm OR CMAKE_SYSTEM_PROCESSOR STREQUAL armv7-a)
             set(CLR_CMAKE_HOST_UNIX_ARM 1)
+        elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL armv6 OR CMAKE_SYSTEM_PROCESSOR STREQUAL armv6l)
+            set(CLR_CMAKE_HOST_UNIX_ARMV6 1)
         elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL arm64)
             set(CLR_CMAKE_HOST_UNIX_ARM64 1)
         elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL loongarch64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL loongarch64)
@@ -217,6 +219,13 @@ if(CLR_CMAKE_HOST_UNIX_ARM)
     if(CLR_CMAKE_HOST_UNIX_ARMV7L)
         set(CLR_CMAKE_HOST_ARCH_ARMV7L 1)
     endif()
+elseif(CLR_CMAKE_HOST_UNIX_ARMV6)
+    set(CLR_CMAKE_HOST_ARCH_ARMV6 1)
+    set(CLR_CMAKE_HOST_ARCH "armv6")
+
+    if(CLR_CMAKE_HOST_UNIX_ARMV6L)
+        set(CLR_CMAKE_HOST_ARCH_ARMV6L 1)
+    endif()
 elseif(CLR_CMAKE_HOST_UNIX_ARM64)
     set(CLR_CMAKE_HOST_ARCH_ARM64 1)
     set(CLR_CMAKE_HOST_ARCH "arm64")
@@ -277,6 +286,8 @@ if (CLR_CMAKE_TARGET_ARCH STREQUAL x64)
     set(CLR_CMAKE_TARGET_ARCH_LOONGARCH64 1)
   elseif(CLR_CMAKE_TARGET_ARCH STREQUAL arm)
     set(CLR_CMAKE_TARGET_ARCH_ARM 1)
+  elseif(CLR_CMAKE_TARGET_ARCH STREQUAL armv6)
+    set(CLR_CMAKE_TARGET_ARCH_ARMV6 1)
   elseif(CLR_CMAKE_TARGET_ARCH STREQUAL armel)
     set(CLR_CMAKE_TARGET_ARCH_ARM 1)
     set(CLR_CMAKE_TARGET_ARCH_ARMV7L 1)
@@ -379,6 +390,8 @@ if(CLR_CMAKE_TARGET_UNIX)
         set(CLR_CMAKE_TARGET_UNIX_ARM 1)
     elseif(CLR_CMAKE_TARGET_ARCH STREQUAL arm)
         set(CLR_CMAKE_TARGET_UNIX_ARM 1)
+    elseif(CLR_CMAKE_TARGET_ARCH STREQUAL armv6)
+        set(CLR_CMAKE_TARGET_UNIX_ARMV6 1)
     elseif(CLR_CMAKE_TARGET_ARCH STREQUAL arm64)
         set(CLR_CMAKE_TARGET_UNIX_ARM64 1)
     elseif(CLR_CMAKE_TARGET_ARCH STREQUAL loongarch64)
diff --git a/eng/native/configuretools.cmake b/eng/native/configuretools.cmake
index 136cd67925d0cb..ad5dc38107c33f 100644
--- a/eng/native/configuretools.cmake
+++ b/eng/native/configuretools.cmake
@@ -52,8 +52,8 @@ if(NOT WIN32 AND NOT CLR_CMAKE_TARGET_BROWSER)
 
     if(CLR_CMAKE_TARGET_ANDROID)
       set(TOOLSET_PREFIX ${ANDROID_TOOLCHAIN_PREFIX})
-    elseif(CMAKE_CROSSCOMPILING AND NOT DEFINED CLR_CROSS_COMPONENTS_BUILD AND (CMAKE_SYSTEM_PROCESSOR STREQUAL armv7l OR
-       CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL arm OR CMAKE_SYSTEM_PROCESSOR STREQUAL s390x))
+    elseif(CMAKE_CROSSCOMPILING AND NOT DEFINED CLR_CROSS_COMPONENTS_BUILD AND
+        CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7l|armv6l|aarch64|arm|s390x)$")
       set(TOOLSET_PREFIX "${TOOLCHAIN}-")
     else()
       set(TOOLSET_PREFIX "")
diff --git a/eng/native/functions.cmake b/eng/native/functions.cmake
index c4af68ba7dc610..0c28f75706de19 100644
--- a/eng/native/functions.cmake
+++ b/eng/native/functions.cmake
@@ -4,7 +4,7 @@ function(clr_unknown_arch)
     elseif(CLR_CROSS_COMPONENTS_BUILD)
         message(FATAL_ERROR "Only AMD64, I386 host are supported for linux cross-architecture component. Found: ${CMAKE_SYSTEM_PROCESSOR}")
     else()
-        message(FATAL_ERROR "Only AMD64, ARM64, LOONGARCH64 and ARM are supported. Found: ${CMAKE_SYSTEM_PROCESSOR}")
+        message(FATAL_ERROR "Only AMD64, ARMV6, ARM64, LOONGARCH64 and ARM are supported. Found: ${CMAKE_SYSTEM_PROCESSOR}")
     endif()
 endfunction()
 
@@ -155,6 +155,10 @@ function(find_unwind_libs UnwindLibs)
       find_library(UNWIND_ARCH NAMES unwind-arm)
     endif()
 
+    if(CLR_CMAKE_HOST_ARCH_ARMV6)
+      find_library(UNWIND_ARCH NAMES unwind-arm)
+    endif()
+
     if(CLR_CMAKE_HOST_ARCH_ARM64)
       find_library(UNWIND_ARCH NAMES unwind-aarch64)
     endif()
diff --git a/eng/native/init-os-and-arch.sh b/eng/native/init-os-and-arch.sh
index 586534be1c8aa9..eda07a5feebbdf 100644
--- a/eng/native/init-os-and-arch.sh
+++ b/eng/native/init-os-and-arch.sh
@@ -53,6 +53,10 @@ case "$CPUName" in
         fi
         ;;
 
+    armv6l)
+        arch=armv6
+        ;;
+
     i[3-6]86)
         echo "Unsupported CPU $CPUName detected, build might not succeed!"
         arch=x86
diff --git a/eng/native/tryrun.cmake b/eng/native/tryrun.cmake
index e8a04c5698ad35..fca410fcb4b42f 100644
--- a/eng/native/tryrun.cmake
+++ b/eng/native/tryrun.cmake
@@ -68,7 +68,7 @@ if(DARWIN)
   else()
     message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only arm64 or x64 is supported for OSX cross build!")
   endif()
-elseif(TARGET_ARCH_NAME MATCHES "^(armel|arm|arm64|loongarch64|s390x|x86)$" OR FREEBSD OR ILLUMOS)
+elseif(TARGET_ARCH_NAME MATCHES "^(armel|arm|armv6|arm64|loongarch64|s390x|x86)$" OR FREEBSD OR ILLUMOS)
   set_cache_value(FILE_OPS_CHECK_FERROR_OF_PREVIOUS_CALL_EXITCODE 1)
   set_cache_value(GETPWUID_R_SETS_ERRNO_EXITCODE 0)
   set_cache_value(HAS_POSIX_SEMAPHORES_EXITCODE 0)
@@ -146,9 +146,9 @@ elseif(TARGET_ARCH_NAME MATCHES "^(armel|arm|arm64|loongarch64|s390x|x86)$" OR F
     set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 0)
   endif()
 else()
-  message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only armel, arm, arm64, loongarch64, s390x and x86 are supported!")
+  message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only armel, arm, armv6, arm64, loongarch64, s390x and x86 are supported!")
 endif()
 
-if(TARGET_ARCH_NAME STREQUAL "x86" OR TARGET_ARCH_NAME STREQUAL "s390x" OR TARGET_ARCH_NAME STREQUAL "loongarch64")
+if(TARGET_ARCH_NAME STREQUAL "x86" OR TARGET_ARCH_NAME STREQUAL "s390x" OR TARGET_ARCH_NAME STREQUAL "armv6" OR TARGET_ARCH_NAME STREQUAL "loongarch64")
   set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 0)
 endif()
diff --git a/eng/pipelines/common/platform-matrix.yml b/eng/pipelines/common/platform-matrix.yml
index 282fa567550812..0938ee359b4a47 100644
--- a/eng/pipelines/common/platform-matrix.yml
+++ b/eng/pipelines/common/platform-matrix.yml
@@ -52,6 +52,31 @@ jobs:
         crossrootfsDir: '/crossrootfs/arm'
         ${{ insert }}: ${{ parameters.jobParameters }}
 
+# Linux armv6
+- ${{ if or(containsValue(parameters.platforms, 'Linux_armv6'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
+  - template: xplat-setup.yml
+    parameters:
+      jobTemplate: ${{ parameters.jobTemplate }}
+      helixQueuesTemplate: ${{ parameters.helixQueuesTemplate }}
+      variables: ${{ parameters.variables }}
+      osGroup: Linux
+      archType: armv6
+      targetRid: linux-armv6
+      platform: Linux_armv6
+      container:
+        image: ubuntu-20.04-cross-armv6-raspbian-10-20211208135931-e6e3ac4
+        registry: mcr
+      jobParameters:
+        runtimeFlavor: ${{ parameters.runtimeFlavor }}
+        stagedBuild: ${{ parameters.stagedBuild }}
+        buildConfig: ${{ parameters.buildConfig }}
+        ${{ if eq(parameters.passPlatforms, true) }}:
+          platforms: ${{ parameters.platforms }}
+        helixQueueGroup: ${{ parameters.helixQueueGroup }}
+        crossBuild: true
+        crossrootfsDir: '/crossrootfs/armv6'
+        ${{ insert }}: ${{ parameters.jobParameters }}
+
 # Linux arm64
 
 - ${{ if or(containsValue(parameters.platforms, 'Linux_arm64'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml
index dec87138ed4563..70161eb7e19684 100644
--- a/eng/pipelines/libraries/helix-queues-setup.yml
+++ b/eng/pipelines/libraries/helix-queues-setup.yml
@@ -33,6 +33,11 @@ jobs:
         - (Debian.10.Arm32.Open)Ubuntu.1804.ArmArch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-10-helix-arm32v7-20210304164340-6616c63
         - (Debian.11.Arm32.Open)Ubuntu.1804.ArmArch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-11-helix-arm32v7-20210304164347-5a7c380
 
+    # Linux armv6
+    - ${{ if eq(parameters.platform, 'Linux_armv6') }}:
+#      - ${{ if eq(parameters.jobParameters.isFullMatrix, true) }}:
+      - (Raspbian.10.Armv6.Open)Raspbian.9.Arm32.IoT.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:raspbian-10-helix-arm32v6-20211215185610-60748cc
+
     # Linux arm64
     - ${{ if eq(parameters.platform, 'Linux_arm64') }}:
       - ${{ if or(eq(parameters.jobParameters.isExtraPlatforms, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}:
diff --git a/eng/pipelines/runtime-staging.yml b/eng/pipelines/runtime-staging.yml
index d49ceeed3ef533..e06a9a6344d9b9 100644
--- a/eng/pipelines/runtime-staging.yml
+++ b/eng/pipelines/runtime-staging.yml
@@ -234,6 +234,46 @@ jobs:
           eq(variables['monoContainsChange'], true),
           eq(variables['isRollingBuild'], true))
 
+#
+# Build the whole product using Mono and run libraries tests
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    buildConfig: Release
+    runtimeFlavor: mono
+    platforms:
+    - Linux_armv6
+    variables:
+      # map dependencies variables to local variables
+      - name: librariesContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
+      - name: monoContainsChange
+        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
+    jobParameters:
+      testScope: innerloop
+      nameSuffix: AllSubsets_Mono
+      buildArgs: -s mono+clr+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
+      timeoutInMinutes: 120
+      condition: >-
+        or(
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
+          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
+          eq(variables['isManualOrIsNotPR'], true),
+          eq(variables['isFullMatrix'], true))
+      # extra steps, run tests
+      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+      extraStepsParameters:
+        creator: dotnet-bot
+        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
+        condition: >-
+          or(
+          eq(variables['librariesContainsChange'], true),
+          eq(variables['monoContainsChange'], true),
+          eq(variables['isRollingBuild'], true))
+
 #
 # Build the whole product using Mono and run runtime tests with the JIT.
 #
diff --git a/eng/targetingpacks.targets b/eng/targetingpacks.targets
index 4213c84e709d9c..150ddf7401c9ea 100644
--- a/eng/targetingpacks.targets
+++ b/eng/targetingpacks.targets
@@ -43,13 +43,13 @@
                       RuntimeFrameworkName="$(LocalFrameworkOverrideName)"
                       LatestRuntimeFrameworkVersion="$(ProductVersion)"
                       RuntimePackNamePatterns="$(LocalFrameworkOverrideName).Runtime.Mono.**RID**"
-                      RuntimePackRuntimeIdentifiers="linux-arm;linux-arm64;linux-musl-arm64;linux-loongarch64;linux-musl-x64;linux-x64;osx-x64;rhel.6-x64;win-arm;win-arm64;win-x64;win-x86;linux-musl-arm;osx-arm64;maccatalyst-x64;maccatalyst-arm64;browser-wasm;ios-arm64;ios-arm;iossimulator-arm64;iossimulator-x64;iossimulator-x86;tvos-arm64;tvossimulator-arm64;tvossimulator-x64;android-arm64;android-arm;android-x64;android-x86"
+                      RuntimePackRuntimeIdentifiers="linux-arm;linux-armv6;linux-arm64;linux-musl-arm64;linux-loongarch64;linux-musl-x64;linux-x64;osx-x64;rhel.6-x64;win-arm;win-arm64;win-x64;win-x86;linux-musl-arm;osx-arm64;maccatalyst-x64;maccatalyst-arm64;browser-wasm;ios-arm64;ios-arm;iossimulator-arm64;iossimulator-x64;iossimulator-x86;tvos-arm64;tvossimulator-arm64;tvossimulator-x64;android-arm64;android-arm;android-x64;android-x86"
                       RuntimePackLabels="Mono"
                       Condition="'@(KnownRuntimePack)' == '' or !@(KnownRuntimePack->AnyHaveMetadataValue('TargetFramework', '$(NetCoreAppCurrent)'))"/>
     <KnownAppHostPack Include="$(LocalFrameworkOverrideName)" 
                       AppHostPackNamePattern="$(LocalFrameworkOverrideName).Host.**RID**"
                       AppHostPackVersion="$([MSBuild]::ValueOrDefault('$(_AppHostBaselinePackVersion)', '$(ProductVersion)'))"
-                      AppHostRuntimeIdentifiers="linux-arm;linux-arm64;linux-musl-arm64;linux-loongarch64;linux-musl-x64;linux-x64;osx-x64;rhel.6-x64;tizen.4.0.0-armel;tizen.5.0.0-armel;win-arm;win-arm64;win-x64;win-x86;linux-musl-arm;osx-arm64"
+                      AppHostRuntimeIdentifiers="linux-arm;linux-armv6;linux-arm64;linux-musl-arm64;linux-loongarch64;linux-musl-x64;linux-x64;osx-x64;rhel.6-x64;tizen.4.0.0-armel;tizen.5.0.0-armel;win-arm;win-arm64;win-x64;win-x86;linux-musl-arm;osx-arm64"
                       TargetFramework="$(NetCoreAppCurrent)"
                       Condition="'@(KnownAppHostPack)' == '' or !@(KnownAppHostPack->AnyHaveMetadataValue('TargetFramework', '$(NetCoreAppCurrent)'))" />
     <KnownCrossgen2Pack Include="$(LocalFrameworkOverrideName).Crossgen2"
diff --git a/src/coreclr/inc/volatile.h b/src/coreclr/inc/volatile.h
index 610a408f39fb6e..e127fe25f99b1f 100644
--- a/src/coreclr/inc/volatile.h
+++ b/src/coreclr/inc/volatile.h
@@ -73,7 +73,10 @@
 #endif
 
 #if defined(__GNUC__)
-#if defined(HOST_ARM) || defined(HOST_ARM64)
+#if defined(HOST_ARMV6)
+// DMB ISH not valid on ARMv6
+#define VOLATILE_MEMORY_BARRIER() asm volatile ("mcr p15, 0, r0, c7, c10, 5" : : : "memory")
+#elif defined(HOST_ARM) || defined(HOST_ARM64)
 // This is functionally equivalent to the MemoryBarrier() macro used on ARM on Windows.
 #define VOLATILE_MEMORY_BARRIER() asm volatile ("dmb ish" : : : "memory")
 #else
diff --git a/src/coreclr/jit/CMakeLists.txt b/src/coreclr/jit/CMakeLists.txt
index c46cdd18a164ee..ebca7e65daaac7 100644
--- a/src/coreclr/jit/CMakeLists.txt
+++ b/src/coreclr/jit/CMakeLists.txt
@@ -32,6 +32,9 @@ function(create_standalone_jit)
   elseif((TARGETDETAILS_ARCH STREQUAL "arm") OR (TARGETDETAILS_ARCH STREQUAL "armel"))
     set(JIT_ARCH_SOURCES ${JIT_ARM_SOURCES})
     set(JIT_ARCH_HEADERS ${JIT_ARM_HEADERS})
+  elseif((TARGETDETAILS_ARCH STREQUAL "armv6") OR (TARGETDETAILS_ARCH STREQUAL "armv6l"))
+    set(JIT_ARCH_SOURCES ${JIT_ARMV6_SOURCES})
+    set(JIT_ARCH_HEADERS ${JIT_ARMV6_HEADERS})
   elseif(TARGETDETAILS_ARCH STREQUAL "x86")
     set(JIT_ARCH_SOURCES ${JIT_I386_SOURCES})
     set(JIT_ARCH_HEADERS ${JIT_I386_HEADERS})
@@ -220,6 +223,10 @@ set( JIT_ARM64_SOURCES
   hwintrinsiccodegenarm64.cpp
 )
 
+set( JIT_ARMV6_SOURCES
+  # Not supported as JIT target
+)
+
 set( JIT_S390X_SOURCES
   # Not supported as JIT target
 )
@@ -362,6 +369,10 @@ set( JIT_ARM_HEADERS
   registerarm.h
 )
 
+set ( JIT_ARMV6_HEADERS
+  # Not supported as JIT target
+)
+
 set ( JIT_S390X_HEADERS
   # Not supported as JIT target
 )
@@ -380,6 +391,8 @@ convert_to_absolute_path(JIT_I386_SOURCES ${JIT_I386_SOURCES})
 convert_to_absolute_path(JIT_I386_HEADERS ${JIT_I386_HEADERS})
 convert_to_absolute_path(JIT_ARM64_SOURCES ${JIT_ARM64_SOURCES})
 convert_to_absolute_path(JIT_ARM64_HEADERS ${JIT_ARM64_HEADERS})
+convert_to_absolute_path(JIT_ARMV6_SOURCES ${JIT_ARMV6_SOURCES})
+convert_to_absolute_path(JIT_ARMV6_HEADERS ${JIT_ARMV6_HEADERS})
 convert_to_absolute_path(JIT_S390X_SOURCES ${JIT_S390X_SOURCES})
 convert_to_absolute_path(JIT_S390X_HEADERS ${JIT_S390X_HEADERS})
 
@@ -389,6 +402,9 @@ if(CLR_CMAKE_TARGET_ARCH_AMD64)
 elseif(CLR_CMAKE_TARGET_ARCH_ARM)
   set(JIT_ARCH_SOURCES ${JIT_ARM_SOURCES})
   set(JIT_ARCH_HEADERS ${JIT_ARM_HEADERS})
+elseif(CLR_CMAKE_TARGET_ARCH_ARMV6)
+  set(JIT_ARCH_SOURCES ${JIT_ARMV6_SOURCES})
+  set(JIT_ARCH_HEADERS ${JIT_ARMV6_HEADERS})
 elseif(CLR_CMAKE_TARGET_ARCH_I386)
   set(JIT_ARCH_SOURCES ${JIT_I386_SOURCES})
   set(JIT_ARCH_HEADERS ${JIT_I386_HEADERS})
@@ -550,13 +566,13 @@ if (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
 endif (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX)
 
 if (CLR_CMAKE_TARGET_UNIX)
-    if (NOT ARCH_TARGET_NAME STREQUAL s390x)
+    if (NOT ARCH_TARGET_NAME STREQUAL s390x AND NOT ARCH_TARGET_NAME STREQUAL armv6)
       if(CLR_CMAKE_TARGET_ARCH_ARM OR CLR_CMAKE_TARGET_ARCH_ARM64)
         install_clr(TARGETS clrjit_universal_${ARCH_TARGET_NAME}_${ARCH_HOST_NAME} DESTINATIONS . COMPONENT jit)
       else()
         install_clr(TARGETS clrjit_unix_${ARCH_TARGET_NAME}_${ARCH_HOST_NAME} DESTINATIONS . COMPONENT jit)
       endif()
-    endif(NOT ARCH_TARGET_NAME STREQUAL s390x)
+    endif(NOT ARCH_TARGET_NAME STREQUAL s390x AND NOT ARCH_TARGET_NAME STREQUAL armv6)
 endif()
 
 if (CLR_CMAKE_TARGET_WIN32 AND CLR_CMAKE_PGO_INSTRUMENT)
diff --git a/src/coreclr/pal/inc/unixasmmacros.inc b/src/coreclr/pal/inc/unixasmmacros.inc
index 1fe285eef162d2..a1bad6300f3cff 100644
--- a/src/coreclr/pal/inc/unixasmmacros.inc
+++ b/src/coreclr/pal/inc/unixasmmacros.inc
@@ -39,6 +39,8 @@
 #include "unixasmmacrosamd64.inc"
 #elif defined(HOST_ARM)
 #include "unixasmmacrosarm.inc"
+#elif defined(HOST_ARMV6)
+#include "unixasmmacrosarm.inc"
 #elif defined(HOST_ARM64)
 #include "unixasmmacrosarm64.inc"
 #elif defined(HOST_S390X)
diff --git a/src/coreclr/pal/inc/unixasmmacrosarm.inc b/src/coreclr/pal/inc/unixasmmacrosarm.inc
index e0c0016cc26ab2..d323ccc49fbd2d 100644
--- a/src/coreclr/pal/inc/unixasmmacrosarm.inc
+++ b/src/coreclr/pal/inc/unixasmmacrosarm.inc
@@ -197,7 +197,11 @@ C_FUNC(\Name\()_End):
 .endm
 
 .macro EMIT_BREAKPOINT
+#ifdef __armv6__
+        .inst 0xe7f001f0
+#else
         .inst.w 0xde01
+#endif
 .endm
 
 .macro PROLOG_PUSH RegList
diff --git a/src/coreclr/pal/src/CMakeLists.txt b/src/coreclr/pal/src/CMakeLists.txt
index a9beb759b892ff..29765f81ea77ac 100644
--- a/src/coreclr/pal/src/CMakeLists.txt
+++ b/src/coreclr/pal/src/CMakeLists.txt
@@ -45,6 +45,9 @@ if(CLR_CMAKE_HOST_ARCH_AMD64)
   set(PAL_ARCH_SOURCES_DIR amd64)
 elseif(CLR_CMAKE_HOST_ARCH_ARM)
   set(PAL_ARCH_SOURCES_DIR arm)
+elseif(CLR_CMAKE_HOST_ARCH_ARMV6)
+  set(PAL_ARCH_SOURCES_DIR arm)
+  add_definitions(-D__armv6__)
 elseif(CLR_CMAKE_HOST_ARCH_ARM64)
   set(PAL_ARCH_SOURCES_DIR arm64)
 elseif(CLR_CMAKE_HOST_ARCH_I386)
diff --git a/src/coreclr/pal/src/arch/arm/callsignalhandlerwrapper.S b/src/coreclr/pal/src/arch/arm/callsignalhandlerwrapper.S
index 4179f61e16276d..a7c92e93188e46 100644
--- a/src/coreclr/pal/src/arch/arm/callsignalhandlerwrapper.S
+++ b/src/coreclr/pal/src/arch/arm/callsignalhandlerwrapper.S
@@ -5,7 +5,9 @@
 #include "asmconstants.h"
 
 .syntax unified
+#ifndef __armv6__
 .thumb
+#endif
 
 .macro CALL_SIGNAL_HANDLER_WRAPPER Alignment
 
diff --git a/src/coreclr/pal/src/arch/arm/context2.S b/src/coreclr/pal/src/arch/arm/context2.S
index 1cd7684a953e8e..edb5d35bf1e40c 100644
--- a/src/coreclr/pal/src/arch/arm/context2.S
+++ b/src/coreclr/pal/src/arch/arm/context2.S
@@ -10,7 +10,9 @@
 #include "asmconstants.h"
 
 .syntax unified
+#ifndef __armv6__
 .thumb
+#endif
 
 #define CONTEXT_ARM     0x00200000
 
diff --git a/src/coreclr/pal/src/arch/arm/debugbreak.S b/src/coreclr/pal/src/arch/arm/debugbreak.S
index dd8a9348352dcc..88301b98548c35 100644
--- a/src/coreclr/pal/src/arch/arm/debugbreak.S
+++ b/src/coreclr/pal/src/arch/arm/debugbreak.S
@@ -4,7 +4,9 @@
 #include "unixasmmacros.inc"
 
 .syntax unified
+#ifndef __armv6__
 .thumb
+#endif
 
 LEAF_ENTRY DBG_DebugBreak, _TEXT
     EMIT_BREAKPOINT
diff --git a/src/coreclr/pal/src/arch/arm/exceptionhelper.S b/src/coreclr/pal/src/arch/arm/exceptionhelper.S
index f733aad613379d..a43ed14be7d983 100644
--- a/src/coreclr/pal/src/arch/arm/exceptionhelper.S
+++ b/src/coreclr/pal/src/arch/arm/exceptionhelper.S
@@ -5,7 +5,9 @@
 #include "asmconstants.h"
 
 .syntax unified
+#ifndef __armv6__
 .thumb
+#endif
 
 // EXTERN_C void ThrowExceptionFromContextInternal(CONTEXT* context, PAL_SEHException* ex);
 LEAF_ENTRY ThrowExceptionFromContextInternal, _TEXT
diff --git a/src/coreclr/pal/src/libunwind/CMakeLists.txt b/src/coreclr/pal/src/libunwind/CMakeLists.txt
index 17659432fd0e4d..dfcd140a89a5be 100644
--- a/src/coreclr/pal/src/libunwind/CMakeLists.txt
+++ b/src/coreclr/pal/src/libunwind/CMakeLists.txt
@@ -19,6 +19,7 @@ add_definitions(-D_GNU_SOURCE)
 add_definitions(-DPACKAGE_STRING="")
 add_definitions(-DPACKAGE_BUGREPORT="")
 
+
 if(CLR_CMAKE_HOST_UNIX)
     if (CLR_CMAKE_HOST_ARCH_AMD64)
       set(arch x86_64)
@@ -26,6 +27,8 @@ if(CLR_CMAKE_HOST_UNIX)
       set(arch aarch64)
     elseif(CLR_CMAKE_HOST_ARCH_ARM)
       set(arch arm)
+    elseif(CLR_CMAKE_HOST_ARCH_ARMV6)
+      set(arch arm)
     elseif(CLR_CMAKE_HOST_ARCH_I386)
         set(arch x86)
     elseif(CLR_CMAKE_HOST_ARCH_S390X)
@@ -45,7 +48,7 @@ if(CLR_CMAKE_HOST_UNIX)
       add_compile_options(-Wno-incompatible-pointer-types)
     endif()
 
-    if(CLR_CMAKE_HOST_ARCH_ARM)
+    if(CLR_CMAKE_HOST_ARCH_ARM OR CLR_CMAKE_HOST_ARCH_ARMV6)
         # Ensure that the remote and local unwind code can reside in the same binary without name clashing
         add_definitions("-Darm_search_unwind_table=UNW_OBJ(arm_search_unwind_table)")
         if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
@@ -109,6 +112,10 @@ if(CLR_CMAKE_HOST_WIN32)
       set(TARGET_ARM 1)
       set(arch arm)
       add_definitions(-D__arm__)
+    elseif(CLR_CMAKE_TARGET_ARCH_ARMV6)
+      set(TARGET_ARM 1)
+      set(arch arm)
+      add_definitions(-D__arm__)
     elseif(CLR_CMAKE_TARGET_ARCH_S390X)
       set(TARGET_S390X 1)
       set(arch s390x)
@@ -155,7 +162,7 @@ if(CLR_CMAKE_HOST_WIN32)
     add_compile_options(-wd4477) # fprintf argument type
 endif (CLR_CMAKE_HOST_WIN32)
 
-if(CLR_CMAKE_TARGET_ARCH_ARM)
+if(CLR_CMAKE_TARGET_ARCH_ARM OR CLR_CMAKE_TARGET_ARCH_ARMV6)
     # The arm sources include ex_tables.h from include/tdep-arm without going through a redirection
     # in include/tdep like it works for similar files on other architectures. So we need to add
     # the include/tdep-arm to include directories
diff --git a/src/coreclr/pal/src/libunwind/src/CMakeLists.txt b/src/coreclr/pal/src/libunwind/src/CMakeLists.txt
index b6dee4f413a809..17a30e027e03e8 100644
--- a/src/coreclr/pal/src/libunwind/src/CMakeLists.txt
+++ b/src/coreclr/pal/src/libunwind/src/CMakeLists.txt
@@ -316,6 +316,11 @@ if(CLR_CMAKE_HOST_UNIX)
         SET(libunwind_remote_la_SOURCES             ${libunwind_arm_la_SOURCES_arm})
         SET(libunwind_elf_la_SOURCES                ${libunwind_elf32_la_SOURCES})
         list(APPEND libunwind_setjmp_la_SOURCES     arm/siglongjmp.S)
+    elseif(CLR_CMAKE_HOST_ARCH_ARMV6)
+        SET(libunwind_la_SOURCES                    ${libunwind_la_SOURCES_arm})
+        SET(libunwind_remote_la_SOURCES             ${libunwind_arm_la_SOURCES_arm})
+        SET(libunwind_elf_la_SOURCES                ${libunwind_elf32_la_SOURCES})
+        list(APPEND libunwind_setjmp_la_SOURCES     arm/siglongjmp.S)
     elseif(CLR_CMAKE_HOST_ARCH_I386)
         SET(libunwind_la_SOURCES                    ${libunwind_la_SOURCES_x86} ${libunwind_x86_la_SOURCES_os})
         SET(libunwind_remote_la_SOURCES             ${libunwind_x86_la_SOURCES_x86})
@@ -363,6 +368,11 @@ else(CLR_CMAKE_HOST_UNIX)
         SET(libunwind_remote_la_SOURCES             ${libunwind_arm_la_SOURCES_arm})
         SET(libunwind_elf_la_SOURCES                ${libunwind_elf32_la_SOURCES})
         list(APPEND libunwind_setjmp_la_SOURCES     arm/siglongjmp.S)
+    elseif(CLR_CMAKE_TARGET_ARCH_ARMV6)
+        SET(libunwind_la_SOURCES                    ${libunwind_la_SOURCES_arm})
+        SET(libunwind_remote_la_SOURCES             ${libunwind_arm_la_SOURCES_arm})
+        SET(libunwind_elf_la_SOURCES                ${libunwind_elf32_la_SOURCES})
+        list(APPEND libunwind_setjmp_la_SOURCES     arm/siglongjmp.S)
     elseif(CLR_CMAKE_TARGET_ARCH_I386)
         SET(libunwind_la_SOURCES                    ${libunwind_la_SOURCES_x86} ${libunwind_x86_la_SOURCES_os})
         SET(libunwind_remote_la_SOURCES             ${libunwind_x86_la_SOURCES_x86})
diff --git a/src/installer/pkg/projects/netcoreappRIDs.props b/src/installer/pkg/projects/netcoreappRIDs.props
index 37fa250ded667b..6282d87b88a92b 100644
--- a/src/installer/pkg/projects/netcoreappRIDs.props
+++ b/src/installer/pkg/projects/netcoreappRIDs.props
@@ -26,6 +26,9 @@
     <OfficialBuildRID Include="linux-arm">
       <Platform>arm</Platform>
     </OfficialBuildRID>
+    <OfficialBuildRID Include="linux-armv6">
+      <Platform>armv6</Platform>
+    </OfficialBuildRID>
     <OfficialBuildRID Include="linux-arm64">
       <Platform>arm64</Platform>
     </OfficialBuildRID>
diff --git a/src/libraries/Microsoft.NETCore.Platforms/src/runtime.compatibility.json b/src/libraries/Microsoft.NETCore.Platforms/src/runtime.compatibility.json
index 25a77800588447..fc0fb68ac6e7e4 100644
--- a/src/libraries/Microsoft.NETCore.Platforms/src/runtime.compatibility.json
+++ b/src/libraries/Microsoft.NETCore.Platforms/src/runtime.compatibility.json
@@ -3760,6 +3760,14 @@
     "any",
     "base"
   ],
+  "linux-armv6": [
+    "linux-armv6",
+    "linux",
+    "unix-armv6",
+    "unix",
+    "any",
+    "base"
+  ],
   "linux-mips64": [
     "linux-mips64",
     "linux",
@@ -8248,6 +8256,12 @@
     "any",
     "base"
   ],
+  "unix-armv6": [
+    "unix-armv6",
+    "unix",
+    "any",
+    "base"
+  ],
   "unix-mips64": [
     "unix-mips64",
     "unix",
@@ -8902,4 +8916,4 @@
     "any",
     "base"
   ]
-}
\ No newline at end of file
+}
diff --git a/src/libraries/Microsoft.NETCore.Platforms/src/runtime.json b/src/libraries/Microsoft.NETCore.Platforms/src/runtime.json
index f8c398707e0bb6..0b71f880e893d5 100644
--- a/src/libraries/Microsoft.NETCore.Platforms/src/runtime.json
+++ b/src/libraries/Microsoft.NETCore.Platforms/src/runtime.json
@@ -1504,6 +1504,12 @@
         "unix-loongarch64"
       ]
     },
+    "linux-armv6": {
+      "#import": [
+        "linux",
+        "unix-armv6"
+      ]
+    },
     "linux-mips64": {
       "#import": [
         "linux",
@@ -3444,6 +3450,11 @@
         "unix"
       ]
     },
+    "unix-armv6": {
+      "#import": [
+        "unix"
+      ]
+    },
     "unix-mips64": {
       "#import": [
         "unix"
@@ -3788,4 +3799,4 @@
       ]
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/libraries/Microsoft.NETCore.Platforms/src/runtimeGroups.props b/src/libraries/Microsoft.NETCore.Platforms/src/runtimeGroups.props
index d1613c4345b314..da7960a1f57856 100644
--- a/src/libraries/Microsoft.NETCore.Platforms/src/runtimeGroups.props
+++ b/src/libraries/Microsoft.NETCore.Platforms/src/runtimeGroups.props
@@ -3,11 +3,11 @@
   <ItemGroup>
     <RuntimeGroup Include="unix">
       <Parent>any</Parent>
-      <Architectures>x64;x86;arm;armel;arm64;loongarch64;mips64;s390x</Architectures>
+      <Architectures>x64;x86;arm;armv6;armel;arm64;loongarch64;mips64;s390x</Architectures>
     </RuntimeGroup>
     <RuntimeGroup Include="linux">
       <Parent>unix</Parent>
-      <Architectures>x64;x86;arm;armel;arm64;loongarch64;mips64;s390x</Architectures>
+      <Architectures>x64;x86;arm;armv6;armel;arm64;loongarch64;mips64;s390x</Architectures>
     </RuntimeGroup>
     <RuntimeGroup Include="linux-musl">
       <Parent>linux</Parent>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Architecture.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Architecture.cs
index 225fec28c763ac..4dead88ce4c92f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Architecture.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Architecture.cs
@@ -11,6 +11,7 @@ public enum Architecture
         Arm64,
         Wasm,
         S390x,
-        LoongArch64
+        LoongArch64,
+        Armv6,
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/RuntimeInformation.ProcessArchitecture.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/RuntimeInformation.ProcessArchitecture.cs
index 0da595b95e0746..d11391a001ef92 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/RuntimeInformation.ProcessArchitecture.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/RuntimeInformation.ProcessArchitecture.cs
@@ -10,6 +10,8 @@ public static Architecture ProcessArchitecture
             => Architecture.X86;
 #elif TARGET_AMD64
             => Architecture.X64;
+#elif TARGET_ARMV6
+            => Architecture.Armv6;
 #elif TARGET_ARM
             => Architecture.Arm;
 #elif TARGET_ARM64
diff --git a/src/libraries/System.Runtime.InteropServices.RuntimeInformation/tests/CheckArchitectureTests.cs b/src/libraries/System.Runtime.InteropServices.RuntimeInformation/tests/CheckArchitectureTests.cs
index 6f1b289fd00eea..50fe5210c91ad5 100644
--- a/src/libraries/System.Runtime.InteropServices.RuntimeInformation/tests/CheckArchitectureTests.cs
+++ b/src/libraries/System.Runtime.InteropServices.RuntimeInformation/tests/CheckArchitectureTests.cs
@@ -44,6 +44,10 @@ public void VerifyArchitecture()
                     Assert.Equal(Architecture.LoongArch64, processArch);
                     break;
 
+                case Architecture.Armv6:
+                    Assert.Equal(Architecture.Armv6, processArch);
+                    break;
+
                 default:
                     Assert.False(true, "Unexpected Architecture.");
                     break;
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index 57c9f8368994eb..ea9cc7ecc01808 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -13452,6 +13452,7 @@ public enum Architecture
         Wasm = 4,
         S390x = 5,
         LoongArch64 = 6,
+        Armv6 = 7,
     }
     public enum CharSet
     {
diff --git a/src/libraries/externals.csproj b/src/libraries/externals.csproj
index 54ef0d14897c6f..c04d47d9f897e7 100644
--- a/src/libraries/externals.csproj
+++ b/src/libraries/externals.csproj
@@ -9,7 +9,7 @@
     <BinPlaceNative>true</BinPlaceNative>
     <BinPlaceRuntime>false</BinPlaceRuntime>
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-    <UseLiveBuiltDotNetHost Condition="'$(TargetArchitecture)' == 's390x'">true</UseLiveBuiltDotNetHost>
+    <UseLiveBuiltDotNetHost Condition="'$(TargetArchitecture)' == 's390x' or '$(TargetArchitecture)' == 'armv6'">true</UseLiveBuiltDotNetHost>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(DotNetBuildFromSource)' != 'true'">
diff --git a/src/libraries/tests.proj b/src/libraries/tests.proj
index 8d6a97b157d41a..2e5554df5bc5bc 100644
--- a/src/libraries/tests.proj
+++ b/src/libraries/tests.proj
@@ -47,7 +47,7 @@ Roslyn4.0.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Transactions.Local\tests\System.Transactions.Local.Tests.csproj" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetsMobile)' == 'true'">
+  <ItemGroup Condition="'$(TargetsMobile)' == 'true' or '$(TargetArchitecture)' == 'ARMv6'">
     <!-- DllImportGenerator runtime tests depend on DNNE, which does not support mobile platforms. -->
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime.InteropServices\tests\DllImportGenerator.Tests\DllImportGenerator.Tests.csproj" />
     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime.InteropServices\tests\DllImportGenerator.UnitTests\DllImportGenerator.Unit.Tests.csproj" />
diff --git a/src/mono/CMakeLists.txt b/src/mono/CMakeLists.txt
index 79d238e6eeb28a..909e1f72c19dca 100644
--- a/src/mono/CMakeLists.txt
+++ b/src/mono/CMakeLists.txt
@@ -9,6 +9,7 @@ project(mono)
 include(../../eng/native/configurepaths.cmake)
 include(${CLR_ENG_NATIVE_DIR}/functions.cmake)
 
+set(CROSS_ROOTFS $ENV{ROOTFS_DIR})
 set(CMAKE_C_FLAGS_CHECKED "")
 set(CMAKE_CXX_FLAGS_CHECKED "")
 set(CMAKE_EXE_LINKER_FLAGS_CHECKED "")
@@ -420,8 +421,13 @@ elseif(TARGET_ARCH STREQUAL "arm64")
 elseif(TARGET_ARCH MATCHES "arm")
   set(TARGET_ARM 1)
   set(MONO_ARCHITECTURE "\"arm\"")
-  # FIXME:
-  add_definitions("-DARM_FPU_VFP=1")
+  if(MONO_ARM_FPU STREQUAL "none")
+    add_definitions("-DARM_FPU_NONE=1")
+  elseif(MONO_ARM_FPU STREQUAL "vfp-hard")
+    add_definitions("-DARM_FPU_VFP_HARD=1")
+  else()
+    add_definitions("-DARM_FPU_VFP=1")
+  endif()
   set(TARGET_SIZEOF_VOID_P 4)
   set(SIZEOF_REGISTER 4)
   # fixme: use separate defines for host/target
@@ -644,6 +650,9 @@ elseif(HOST_ANDROID)
   set(HAVE_SYS_ICU 1)
 elseif(HOST_LINUX)
   include(FindPkgConfig)
+  if(CROSS_ROOTFS)
+    set(ENV{PKG_CONFIG_ICU_UC_INCLUDEDIR} "${CROSS_ROOTFS}/usr/include")
+  endif(CROSS_ROOTFS)
   pkg_check_modules(ICU icu-uc)
   set(ICU_FLAGS "-DTARGET_UNIX -DU_DISABLE_RENAMING -Wno-reserved-id-macro -Wno-documentation -Wno-documentation-unknown-command -Wno-switch-enum -Wno-covered-switch-default -Wno-extra-semi-stmt -Wno-unknown-warning-option -Wno-deprecated-declarations")
   set(HAVE_SYS_ICU 1)
diff --git a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj
index da99b06e81b8ea..d952686ac56b89 100644
--- a/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj
+++ b/src/mono/System.Private.CoreLib/System.Private.CoreLib.csproj
@@ -10,7 +10,7 @@
     <!-- Force System.Private.CoreLib.dll into a special IL output directory -->
     <OutputPath>$(RuntimeBinDir)IL/</OutputPath>
     <Configurations>Debug;Release;Checked</Configurations>
-    <Platforms>x64;x86;arm;arm64;s390x;wasm</Platforms>
+    <Platforms>x64;x86;arm;armv6;arm64;s390x;wasm</Platforms>
 
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
   </PropertyGroup>
@@ -56,6 +56,10 @@
     <PlatformTarget>x86</PlatformTarget>
     <DefineConstants>$(DefineConstants);TARGET_X86</DefineConstants>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)' == 'armv6'">
+    <PlatformTarget>arm</PlatformTarget>
+    <DefineConstants>$(DefineConstants);TARGET_ARMV6</DefineConstants>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Platform)' == 'arm'">
     <PlatformTarget>arm</PlatformTarget>
     <DefineConstants>$(DefineConstants);TARGET_ARM</DefineConstants>
diff --git a/src/mono/mono.proj b/src/mono/mono.proj
index c7febf933f5c97..bff71d03b47e9c 100644
--- a/src/mono/mono.proj
+++ b/src/mono/mono.proj
@@ -228,12 +228,23 @@
     </ItemGroup>
 
     <!-- ARM Linux cross build options on CI -->
-    <ItemGroup Condition="'$(TargetsAndroid)' != 'true' and '$(MonoCrossDir)' != '' and ('$(TargetArchitecture)' == 'arm' or '$(TargetArchitecture)' == 'arm64')">
+    <ItemGroup Condition="'$(TargetsAndroid)' != 'true' and '$(MonoCrossDir)' != '' and ('$(TargetArchitecture)' == 'arm' or '$(TargetArchitecture)' == 'armv6' or '$(TargetArchitecture)' == 'arm64')">
       <_MonoCMakeArgs Include="-DCMAKE_TOOLCHAIN_FILE=$(CrossToolchainFile)" />
+      <_MonoCMakeArgs Condition="'$(TargetOS)' == 'Linux' and ('$(TargetArchitecture)' == 'arm' or '$(TargetArchitecture)' == 'armv6')" Include="-DMONO_ARM_FPU=vfp-hard" />
       <_MonoBuildEnv Condition="'$(Platform)' == 'arm64'" Include="TARGET_BUILD_ARCH=arm64" />
       <_MonoBuildEnv Condition="'$(Platform)' == 'arm'" Include="TARGET_BUILD_ARCH=arm" />
+      <_MonoBuildEnv Condition="'$(Platform)' == 'armv6'" Include="TARGET_BUILD_ARCH=armv6" />
       <_MonoBuildEnv Condition="'$(Platform)' == 'arm64'" Include="PKG_CONFIG_PATH=$(MonoCrossDir)/usr/lib/aarch64-linux-gnu/pkgconfig" />
       <_MonoBuildEnv Condition="'$(Platform)' == 'arm'" Include="PKG_CONFIG_PATH=$(MonoCrossDir)/usr/lib/arm-linux-gnueabihf/pkgconfig" />
+      <_MonoBuildEnv Condition="'$(Platform)' == 'armv6'" Include="PKG_CONFIG_PATH=$(MonoCrossDir)/usr/lib/arm-linux-gnueabihf/pkgconfig" />
+      <_MonoCFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-march=armv6zk" />
+      <_MonoCFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-mcpu=arm1176jzf-s" />
+      <_MonoCFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-mfpu=vfp" />
+      <_MonoCFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-mfloat-abi=hard" />
+      <_MonoCXXFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-march=armv6zk" />
+      <_MonoCXXFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-mcpu=arm1176jzf-s" />
+      <_MonoCXXFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-mfpu=vfp" />
+      <_MonoCXXFLAGS Condition="'$(TargetArchitecture)' == 'armv6'" Include="-mfloat-abi=hard" />
     </ItemGroup>
 
     <!-- x64 illumos cross build options -->
@@ -514,6 +525,7 @@
       <_LinuxFloatAbi Condition="'$(TargetsAndroid)' != 'true'">hf</_LinuxFloatAbi>
       <_Objcopy>objcopy</_Objcopy>
       <_Objcopy Condition="'$(Platform)' == 'arm'">arm-linux-$(_LinuxAbi)eabi$(_LinuxFloatAbi)-$(_Objcopy)</_Objcopy>
+      <_Objcopy Condition="'$(Platform)' == 'armv6'">arm-linux-$(_LinuxAbi)eabi$(_LinuxFloatAbi)-$(_Objcopy)</_Objcopy>
       <_Objcopy Condition="'$(Platform)' == 'arm64'">aarch64-linux-$(_LinuxAbi)-$(_Objcopy)</_Objcopy>
       <_Objcopy Condition="'$(Platform)' == 's390x'">s390x-linux-$(_LinuxAbi)-$(_Objcopy)</_Objcopy>
       <_Objcopy Condition="'$(Platform)' == 'x64'">x86_64-linux-$(_LinuxAbi)-$(_Objcopy)</_Objcopy>
diff --git a/src/native/corehost/fxr/standalone/CMakeLists.txt b/src/native/corehost/fxr/standalone/CMakeLists.txt
index 42785ac91d4b64..5e30750ab4a607 100644
--- a/src/native/corehost/fxr/standalone/CMakeLists.txt
+++ b/src/native/corehost/fxr/standalone/CMakeLists.txt
@@ -56,3 +56,7 @@ else()
 endif(WIN32)
 
 target_link_libraries(hostfxr libhostcommon)
+
+if (CLR_CMAKE_TARGET_ARCH_ARMV6)
+    target_link_libraries(${DOTNET_PROJECT_NAME} atomic)
+endif()
diff --git a/src/native/corehost/hostmisc/utils.cpp b/src/native/corehost/hostmisc/utils.cpp
index 7f5fdbca40ab03..18e54a3e6d7f86 100644
--- a/src/native/corehost/hostmisc/utils.cpp
+++ b/src/native/corehost/hostmisc/utils.cpp
@@ -191,6 +191,8 @@ const pal::char_t* get_arch()
     return _X("x64");
 #elif defined(TARGET_X86)
     return _X("x86");
+#elif defined(TARGET_ARMV6)
+    return _X("armv6");
 #elif defined(TARGET_ARM)
     return _X("arm");
 #elif defined(TARGET_ARM64)
diff --git a/src/native/corehost/test/nativehost/CMakeLists.txt b/src/native/corehost/test/nativehost/CMakeLists.txt
index c21e95a1c71d9d..d8b23ca12ce568 100644
--- a/src/native/corehost/test/nativehost/CMakeLists.txt
+++ b/src/native/corehost/test/nativehost/CMakeLists.txt
@@ -58,3 +58,7 @@ endif()
 if (CLR_CMAKE_TARGET_WIN32 AND (CLR_CMAKE_TARGET_ARCH_ARM OR CLR_CMAKE_TARGET_ARCH_ARM64))
     target_link_libraries(${DOTNET_PROJECT_NAME} Ole32.lib OleAut32.lib)
 endif()
+
+if (CLR_CMAKE_TARGET_ARCH_ARMV6)
+    target_link_libraries(${DOTNET_PROJECT_NAME} atomic)
+endif()
diff --git a/src/native/eventpipe/ep-event-source.c b/src/native/eventpipe/ep-event-source.c
index 78d1c4852b991c..0da7ebc50caad0 100644
--- a/src/native/eventpipe/ep-event-source.c
+++ b/src/native/eventpipe/ep-event-source.c
@@ -34,6 +34,8 @@ const ep_char8_t* _ep_os_info = "Unknown";
 const ep_char8_t* _ep_arch_info = "x86";
 #elif defined(TARGET_AMD64)
 const ep_char8_t* _ep_arch_info = "x64";
+#elif defined(TARGET_ARMV6)
+const ep_char8_t* _ep_arch_info = "arm32";
 #elif defined(TARGET_ARM)
 const ep_char8_t* _ep_arch_info = "arm32";
 #elif defined(TARGET_ARM64)
diff --git a/src/native/libs/System.Native/pal_runtimeinformation.h b/src/native/libs/System.Native/pal_runtimeinformation.h
index adae223d48339b..da39ac51d55acf 100644
--- a/src/native/libs/System.Native/pal_runtimeinformation.h
+++ b/src/native/libs/System.Native/pal_runtimeinformation.h
@@ -23,5 +23,6 @@ enum
     ARCH_ARM64,
     ARCH_WASM,
     ARCH_S390X,
-    ARCH_LOONGARCH64
+    ARCH_LOONGARCH64,
+    ARCH_ARMV6,
 };

From 9eb1b0c8e52f3a9899b787d425c99a6ddf0eb391 Mon Sep 17 00:00:00 2001
From: Jan Vorlicek <jan.vorlicek@volny.cz>
Date: Mon, 24 Jan 2022 22:58:47 +0100
Subject: [PATCH 044/161] Fix remote unwind (#64220)

The _OOP_find_proc_info was setting only a couple of members of the
unw_dyn_info_t instance on stack. So the remaining ones had random
values. The load_offset was a recently added member to the struct.
When we have updated libunwind, this change came in. The load_offset was
random and that has broken unwindign as this offset is subtracted from
the IP when looking up unwind info.

The fix clears the whole struct. I have verified that the issue we had no
longer happens with the fix.
---
 src/coreclr/pal/src/libunwind/src/oop/_OOP_find_proc_info.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/coreclr/pal/src/libunwind/src/oop/_OOP_find_proc_info.c b/src/coreclr/pal/src/libunwind/src/oop/_OOP_find_proc_info.c
index 74d42ffe2abb28..07bd4a73b276cc 100644
--- a/src/coreclr/pal/src/libunwind/src/oop/_OOP_find_proc_info.c
+++ b/src/coreclr/pal/src/libunwind/src/oop/_OOP_find_proc_info.c
@@ -28,6 +28,8 @@ _OOP_find_proc_info (
     int ret = 0;
 
     unw_dyn_info_t di;
+    memset(&di, 0, sizeof(di));
+
     di.start_ip = start_ip;
     di.end_ip = end_ip;
     di.gp = pi->gp;

From 070b7d80114354ba9ef5dfb8bd175ca832edb638 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Mon, 24 Jan 2022 17:05:04 -0500
Subject: [PATCH 045/161] Put back FindCaseSensitivePrefix regex alternation
 support (#64204)

* Put back FindCaseSensitivePrefix alternation support

* Fix the bug from the initial version, and add more comments
---
 .../RegexFindOptimizations.cs                 |  2 +-
 .../RegularExpressions/RegexPrefixAnalyzer.cs | 59 ++++++++++++++++++-
 .../tests/Regex.Match.Tests.cs                |  4 ++
 3 files changed, 61 insertions(+), 4 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs
index f3c5552b8404af..e3c760c2728be5 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs
@@ -50,7 +50,7 @@ public RegexFindOptimizations(RegexTree tree, CultureInfo culture)
             }
 
             // If there's a leading case-sensitive substring, just use IndexOf and inherit all of its optimizations.
-            string caseSensitivePrefix = RegexPrefixAnalyzer.FindCaseSensitivePrefix(tree);
+            string caseSensitivePrefix = RegexPrefixAnalyzer.FindCaseSensitivePrefix(tree.Root);
             if (caseSensitivePrefix.Length > 1)
             {
                 LeadingCaseSensitivePrefix = caseSensitivePrefix;
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs
index 869b5cc5aa285a..692ee7d5557c1a 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs
@@ -50,11 +50,11 @@ private RegexPrefixAnalyzer(Span<int> intStack)
             _skipAllChildren = false;
         }
 
-        /// <summary>Computes the leading substring in <paramref name="tree"/>; may be empty.</summary>
-        public static string FindCaseSensitivePrefix(RegexTree tree)
+        /// <summary>Computes the leading substring in <paramref name="node"/>; may be empty.</summary>
+        public static string FindCaseSensitivePrefix(RegexNode node)
         {
             var vsb = new ValueStringBuilder(stackalloc char[64]);
-            Process(tree.Root, ref vsb);
+            Process(node, ref vsb);
             return vsb.ToString();
 
             // Processes the node, adding any prefix text to the builder.
@@ -87,6 +87,59 @@ static bool Process(RegexNode node, ref ValueStringBuilder vsb)
                             return !rtl;
                         }
 
+                    // Alternation: find a string that's a shared prefix of all branches
+                    case RegexNodeKind.Alternate:
+                        {
+                            int childCount = node.ChildCount();
+
+                            // Store the initial branch into the target builder, keeping track
+                            // of how much was appended. Any of this contents that doesn't overlap
+                            // will every other branch will be removed before returning.
+                            int initialLength = vsb.Length;
+                            Process(node.Child(0), ref vsb);
+                            int addedLength = vsb.Length - initialLength;
+
+                            // Then explore the rest of the branches, finding the length
+                            // of prefix they all share in common with the initial branch.
+                            if (addedLength != 0)
+                            {
+                                var alternateSb = new ValueStringBuilder(64);
+
+                                // Process each branch.  If we reach a point where we've proven there's
+                                // no overlap, we can bail early.
+                                for (int i = 1; i < childCount && addedLength != 0; i++)
+                                {
+                                    alternateSb.Length = 0;
+
+                                    // Process the branch into a temporary builder.
+                                    Process(node.Child(i), ref alternateSb);
+
+                                    // Find how much overlap there is between this branch's prefix
+                                    // and the smallest amount of prefix that overlapped with all
+                                    // the previously seen branches.
+                                    addedLength = Math.Min(addedLength, alternateSb.Length);
+                                    for (int j = 0; j < addedLength; j++)
+                                    {
+                                        if (vsb[initialLength + j] != alternateSb[j])
+                                        {
+                                            addedLength = j;
+                                            break;
+                                        }
+                                    }
+                                }
+
+                                alternateSb.Dispose();
+
+                                // Then cull back on what was added based on the other branches.
+                                vsb.Length = initialLength + addedLength;
+                            }
+
+                            // Don't explore anything after the alternation.  We could make this work if desirable,
+                            // but it's currently not worth the extra complication.  The entire contents of every
+                            // branch would need to be identical other than zero-width anchors/assertions.
+                            return false;
+                        }
+
                     // One character
                     case RegexNodeKind.One when (node.Options & RegexOptions.IgnoreCase) == 0:
                         vsb.Append(node.Ch);
diff --git a/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs b/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
index 8fd3ea6e32231d..005e9b27bb203a 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
@@ -205,6 +205,10 @@ public static IEnumerable<object[]> Match_MemberData()
                 yield return (@"(^|($|a+))bc", " aabc", RegexOptions.None, 0, 5, true, "aabc");
                 yield return (@"yz(^|a+)bc", " yzaabc", RegexOptions.None, 0, 7, true, "yzaabc");
                 yield return (@"(^a|a$) bc", "a bc", RegexOptions.None, 0, 4, true, "a bc");
+                yield return (@"(abcdefg|abcdef|abc|a)h", "    ah  ", RegexOptions.None, 0, 8, true, "ah");
+                yield return (@"(^abcdefg|abcdef|^abc|a)h", "    abcdefh  ", RegexOptions.None, 0, 13, true, "abcdefh");
+                yield return (@"(a|^abcdefg|abcdef|^abc)h", "    abcdefh  ", RegexOptions.None, 0, 13, true, "abcdefh");
+                yield return (@"(abcdefg|abcdef)h", "    abcdefghij  ", RegexOptions.None, 0, 16, true, "abcdefgh");
 
                 if (!RegexHelpers.IsNonBacktracking(engine))
                 {

From db21974134ed636c4e6bbd1a24104dd93c1ebc16 Mon Sep 17 00:00:00 2001
From: Elinor Fung <elfung@microsoft.com>
Date: Mon, 24 Jan 2022 14:57:42 -0800
Subject: [PATCH 046/161] Update tests to expect RemoteExecutor to check exit
 code (#64133)

---
 .../tests/UnitTests/ConsoleLifetimeExitTests.cs      | 12 +++++++-----
 .../tests/FileSystemTests.cs                         |  3 +--
 .../System.Console/tests/CancelKeyPress.Unix.cs      |  2 +-
 .../tests/System/ExitCodeTests.Unix.cs               |  1 +
 .../JsonSerializerContextTests.cs                    |  5 ++---
 5 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs
index 55902bd8a3a9bd..9788e6684fc018 100644
--- a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs
+++ b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs
@@ -105,10 +105,10 @@ await Host.CreateDefaultBuilder()
                         services.AddHostedService<EnsureEnvironmentExitCodeWorker>();
                     })
                     .RunConsoleAsync();
-            });
+            }, new RemoteInvokeOptions() { ExpectedExitCode = 124 });
 
+            // TODO: Remove once https://github.com/dotnet/arcade/issues/5865 is resolved
             remoteHandle.Process.WaitForExit();
-
             Assert.Equal(124, remoteHandle.Process.ExitCode);
         }
 
@@ -130,6 +130,9 @@ await Task.Run(() =>
         [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
         public void EnsureEnvironmentExitDoesntHang()
         {
+            // SIGTERM is only handled on net6.0+, so the workaround to "clobber" the exit code is still in place on .NET Framework
+            int expectedExitCode = PlatformDetection.IsNetFramework ? 0 : 125;
+
             using var remoteHandle = RemoteExecutor.Invoke(async () =>
             {
                 await Host.CreateDefaultBuilder()
@@ -139,12 +142,11 @@ await Host.CreateDefaultBuilder()
                         services.AddHostedService<EnsureEnvironmentExitDoesntHangWorker>();
                     })
                     .RunConsoleAsync();
-            }, new RemoteInvokeOptions() { TimeOut = 30_000 }); // give a 30 second time out, so if this does hang, it doesn't hang for the full timeout
+            }, new RemoteInvokeOptions() { TimeOut = 30_000, ExpectedExitCode = expectedExitCode }); // give a 30 second time out, so if this does hang, it doesn't hang for the full timeout
 
             Assert.True(remoteHandle.Process.WaitForExit(30_000), "The hosted process should have exited within 30 seconds");
 
-            // SIGTERM is only handled on net6.0+, so the workaround to "clobber" the exit code is still in place on NetFramework
-            int expectedExitCode = PlatformDetection.IsNetFramework ? 0 : 125;
+            // TODO: Remove once https://github.com/dotnet/arcade/issues/5865 is resolved
             Assert.Equal(expectedExitCode, remoteHandle.Process.ExitCode);
         }
 
diff --git a/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs b/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs
index d9f981b2425982..a2a8e28e8d17b7 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs
+++ b/src/libraries/Microsoft.VisualBasic.Core/tests/FileSystemTests.cs
@@ -620,8 +620,7 @@ static void remoteWrite(string fileName, string text)
                         }
                     },
                     fileName,
-                    text,
-                    new RemoteInvokeOptions() { ExpectedExitCode = 0 }).Dispose();
+                    text).Dispose();
             }
         }
 
diff --git a/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs b/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs
index e72522bafc58b8..8fd95102c9dbab 100644
--- a/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs
+++ b/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs
@@ -78,7 +78,7 @@ public void ExitDetectionNotBlockedByHandler()
 
             // Release CancelKeyPress
             mre.Set();
-        }).Dispose();
+        }, new RemoteInvokeOptions() { ExpectedExitCode = 130 }).Dispose();
     }
 
     private void HandlerInvokedForSignal(int signalOuter, bool redirectStandardInput)
diff --git a/src/libraries/System.Runtime/tests/System/ExitCodeTests.Unix.cs b/src/libraries/System.Runtime/tests/System/ExitCodeTests.Unix.cs
index 909f700f5c8da4..9fd7ab4f461a98 100644
--- a/src/libraries/System.Runtime/tests/System/ExitCodeTests.Unix.cs
+++ b/src/libraries/System.Runtime/tests/System/ExitCodeTests.Unix.cs
@@ -42,6 +42,7 @@ public void SigTermExitCode(int? exitCodeOnSigterm)
 
             RemoteInvokeOptions options = new RemoteInvokeOptions();
             options.StartInfo.RedirectStandardOutput = true;
+            options.CheckExitCode = false;
             using (RemoteInvokeHandle remoteExecution = RemoteExecutor.Invoke(action, exitCodeOnSigterm?.ToString() ?? string.Empty, options))
             {
                 Process process = remoteExecution.Process;
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/JsonSerializerContextTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/JsonSerializerContextTests.cs
index 7bc91507d9ad53..a9fa26e3279f11 100644
--- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/JsonSerializerContextTests.cs
+++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/JsonSerializerContextTests.cs
@@ -24,7 +24,7 @@ public static void VariousNestingAndVisibilityLevelsAreSupported()
         public static void Converters_AndTypeInfoCreator_NotRooted_WhenMetadataNotPresent()
         {
             RemoteExecutor.Invoke(
-                new Action(() =>
+                () =>
                 {
                     object[] objArr = new object[] { new MyStruct() };
 
@@ -56,8 +56,7 @@ static void AssertFieldNull(string fieldName, JsonSerializerOptions? optionsInst
                         Assert.NotNull(fieldInfo);
                         Assert.Null(fieldInfo.GetValue(optionsInstance));
                     }
-                }),
-                new RemoteInvokeOptions() { ExpectedExitCode = 0 }).Dispose();
+                }).Dispose();
         }
 
         [Fact]

From 8bfb725d887ff1673652f1d59f8b2a7f071b659e Mon Sep 17 00:00:00 2001
From: Maoni Stephens <Maoni0@users.noreply.github.com>
Date: Mon, 24 Jan 2022 15:21:21 -0800
Subject: [PATCH 047/161] update generation_allocation_size correctly for SIP
 regions (#64176)

SIP regions need to update the corresponding generation's generation_allocation_size and since this can be more than 1 gen older than the region's gen, we need to make all generation's alloc size get updated.
---
 src/coreclr/gc/gc.cpp | 39 +++++++++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp
index 9ab892a5ad338d..bc4c11771f2b13 100644
--- a/src/coreclr/gc/gc.cpp
+++ b/src/coreclr/gc/gc.cpp
@@ -20423,23 +20423,33 @@ void gc_heap::gc1()
 
     if (n < max_generation)
     {
-        compute_promoted_allocation (1 + n);
+        int highest_gen_number = 
+#ifdef USE_REGIONS
+            max_generation;
+#else //USE_REGIONS
+            1 + n;
+#endif //USE_REGIONS
+
+        for (int older_gen_idx = (1 + n); older_gen_idx <= highest_gen_number; older_gen_idx++)
+        {
+            compute_promoted_allocation (older_gen_idx);
 
-        dynamic_data* dd = dynamic_data_of (1 + n);
-        size_t new_fragmentation = generation_free_list_space (generation_of (1 + n)) +
-                                   generation_free_obj_space (generation_of (1 + n));
+            dynamic_data* dd = dynamic_data_of (older_gen_idx);
+            size_t new_fragmentation = generation_free_list_space (generation_of (older_gen_idx)) +
+                                       generation_free_obj_space (generation_of (older_gen_idx));
 
 #ifdef BACKGROUND_GC
-        if (current_c_gc_state != c_gc_state_planning)
+            if (current_c_gc_state != c_gc_state_planning)
 #endif //BACKGROUND_GC
-        {
-            if (settings.promotion)
-            {
-                dd_fragmentation (dd) = new_fragmentation;
-            }
-            else
             {
-                //assert (dd_fragmentation (dd) == new_fragmentation);
+                if (settings.promotion)
+                {
+                    dd_fragmentation (dd) = new_fragmentation;
+                }
+                else
+                {
+                    //assert (dd_fragmentation (dd) == new_fragmentation);
+                }
             }
         }
     }
@@ -30125,6 +30135,11 @@ void gc_heap::sweep_region_in_plan (heap_segment* region,
     heap_segment_saved_allocated (region) = heap_segment_allocated (region);
     heap_segment_allocated (region) = last_marked_obj_end;
     heap_segment_plan_allocated (region) = heap_segment_allocated (region);
+
+    int plan_gen_num = heap_segment_plan_gen_num (region);
+    generation_allocation_size (generation_of (plan_gen_num)) += heap_segment_survived (region);
+    dprintf (REGIONS_LOG, ("sip: g%d alloc size is now %Id", plan_gen_num, 
+        generation_allocation_size (generation_of (plan_gen_num))));
 }
 
 inline

From 74d8d0dea0099da8898953b7b094acc3df62741d Mon Sep 17 00:00:00 2001
From: Mitchell Hwang <16830051+mdh1418@users.noreply.github.com>
Date: Mon, 24 Jan 2022 18:46:52 -0500
Subject: [PATCH 048/161] Android remove backward timezones (#64028)

Fixes #63693

It was discovered that Android produces duplicate TimeZone DisplayNames among all timezone IDs in GetSystemTimeZones. These duplicate DisplayNames occur across TimeZone IDs that are aliases, where all except one are backward timezone IDs.

If a name is changed, put its old spelling in the 'backward' file

From the Android TimeZone data file tzdata, it isn't obvious which TimeZone IDs are backward (I find it strange that they're included in the first place), however we discovered that on some versions of Android, there is an adjacent file tzlookup.xml that can aid us in determining which TimeZone IDs are "current" (not backward).

This PR aims to utilize tzlookup.xml when it exists and post-filter's the Populated TimeZone IDs in the AndroidTzData instance by removing IDs and their associated information (byteoffset and length) from the AndroidTzData instance if it is not found in tzlookup.xml. This is using the assumption that all non-backward TimeZone IDs make it to the tzlookup.xml file.

This PR also adds a new TimeZoneInfo Test to check whether or not there are duplicate DisplayNames in GetSystemTimeZones
---
 .../src/System/TimeZoneInfo.Unix.Android.cs   | 92 +++++++++++++++++--
 .../tests/System/TimeZoneInfoTests.cs         | 14 +++
 2 files changed, 97 insertions(+), 9 deletions(-)

diff --git a/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.Unix.Android.cs b/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.Unix.Android.cs
index 53baf4eb65111f..23c1044e1983cd 100644
--- a/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.Unix.Android.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/TimeZoneInfo.Unix.Android.cs
@@ -193,6 +193,7 @@ private sealed class AndroidTzData
             private string[] _ids;
             private int[] _byteOffsets;
             private int[] _lengths;
+            private bool[] _isBackwards;
             private string _tzFileDir;
             private string _tzFilePath;
 
@@ -230,7 +231,7 @@ public AndroidTzData()
                 foreach (var tzFileDir in tzFileDirList)
                 {
                     string tzFilePath = Path.Combine(tzFileDir, TimeZoneFileName);
-                    if (LoadData(tzFilePath))
+                    if (LoadData(tzFileDir, tzFilePath))
                     {
                         _tzFileDir = tzFileDir;
                         _tzFilePath = tzFilePath;
@@ -241,10 +242,62 @@ public AndroidTzData()
                 throw new TimeZoneNotFoundException(SR.TimeZoneNotFound_ValidTimeZoneFileMissing);
             }
 
+            // On some versions of Android, the tzdata file may still contain backward timezone ids.
+            // We attempt to use tzlookup.xml, which is available on some versions of Android to help
+            // validate non-backward timezone ids
+            // tzlookup.xml is an autogenerated file that contains timezone ids in this form:
+            //
+            // <timezones ianaversion="2019b">
+            //   <countryzones>
+            //     <country code="au" default="Australia/Sydney" everutc="n">
+            //       <id alts="Australia/ACT,Australia/Canberra,Australia/NSW">Australia/Sydney</id>
+            //       ...
+            //       ...
+            //       <id>Australia/Eucla</id>
+            //     </country>
+            //     <country ...>
+            //       ...
+            //       ...
+            //       ...
+            //     </country>
+            //   </countryzones>
+            // </timezones>
+            //
+            // Once the timezone cache is populated with the IDs, we reference tzlookup id tags
+            // to determine if an id is backwards and label it as such if they are.
+            private void FilterBackwardIDs(string tzFileDir, out HashSet<string> tzLookupIDs)
+            {
+                tzLookupIDs = new HashSet<string>();
+                try
+                {
+                    using (StreamReader sr = File.OpenText(Path.Combine(tzFileDir, "tzlookup.xml")))
+                    {
+                        string? tzLookupLine;
+                        while (sr.Peek() >= 0)
+                        {
+                            if (!(tzLookupLine = sr.ReadLine())!.AsSpan().TrimStart().StartsWith("<id", StringComparison.Ordinal))
+                                continue;
+
+                            int idStart = tzLookupLine!.IndexOf('>') + 1;
+                            int idLength = tzLookupLine.LastIndexOf("</", StringComparison.Ordinal) - idStart;
+                            if (idStart <= 0 || idLength < 0)
+                            {
+                                // Either the start tag <id ... > or the end tag </id> are not found
+                                continue;
+                            }
+                            string id = tzLookupLine.Substring(idStart, idLength);
+                            tzLookupIDs.Add(id);
+                        }
+                    }
+                }
+                catch {}
+            }
+
             [MemberNotNullWhen(true, nameof(_ids))]
             [MemberNotNullWhen(true, nameof(_byteOffsets))]
             [MemberNotNullWhen(true, nameof(_lengths))]
-            private bool LoadData(string path)
+            [MemberNotNullWhen(true, nameof(_isBackwards))]
+            private bool LoadData(string tzFileDir, string path)
             {
                 if (!File.Exists(path))
                 {
@@ -254,7 +307,7 @@ private bool LoadData(string path)
                 {
                     using (FileStream fs = File.OpenRead(path))
                     {
-                        LoadTzFile(fs);
+                        LoadTzFile(tzFileDir, fs);
                     }
                     return true;
                 }
@@ -266,7 +319,8 @@ private bool LoadData(string path)
             [MemberNotNull(nameof(_ids))]
             [MemberNotNull(nameof(_byteOffsets))]
             [MemberNotNull(nameof(_lengths))]
-            private void LoadTzFile(Stream fs)
+            [MemberNotNull(nameof(_isBackwards))]
+            private void LoadTzFile(string tzFileDir, Stream fs)
             {
                 const int HeaderSize = 24;
                 Span<byte> buffer = stackalloc byte[HeaderSize];
@@ -274,7 +328,7 @@ private void LoadTzFile(Stream fs)
                 ReadTzDataIntoBuffer(fs, 0, buffer);
 
                 LoadHeader(buffer, out int indexOffset, out int dataOffset);
-                ReadIndex(fs, indexOffset, dataOffset);
+                ReadIndex(tzFileDir, fs, indexOffset, dataOffset);
             }
 
             private void LoadHeader(Span<byte> buffer, out int indexOffset, out int dataOffset)
@@ -303,16 +357,17 @@ private void LoadHeader(Span<byte> buffer, out int indexOffset, out int dataOffs
             [MemberNotNull(nameof(_ids))]
             [MemberNotNull(nameof(_byteOffsets))]
             [MemberNotNull(nameof(_lengths))]
-            private void ReadIndex(Stream fs, int indexOffset, int dataOffset)
+            [MemberNotNull(nameof(_isBackwards))]
+            private void ReadIndex(string tzFileDir, Stream fs, int indexOffset, int dataOffset)
             {
                 int indexSize = dataOffset - indexOffset;
                 const int entrySize = 52; // Data entry size
                 int entryCount = indexSize / entrySize;
-
                 _byteOffsets = new int[entryCount];
                 _ids = new string[entryCount];
                 _lengths = new int[entryCount];
-
+                _isBackwards = new bool[entryCount];
+                FilterBackwardIDs(tzFileDir, out HashSet<string> tzLookupIDs);
                 for (int i = 0; i < entryCount; ++i)
                 {
                     LoadEntryAt(fs, indexOffset + (entrySize*i), out string id, out int byteOffset, out int length);
@@ -320,6 +375,7 @@ private void ReadIndex(Stream fs, int indexOffset, int dataOffset)
                     _byteOffsets[i] = byteOffset + dataOffset;
                     _ids[i] = id;
                     _lengths[i] = length;
+                    _isBackwards[i] = !tzLookupIDs.Contains(id);
 
                     if (length < 24) // Header Size
                     {
@@ -372,7 +428,25 @@ private void LoadEntryAt(Stream fs, long position, out string id, out int byteOf
 
             public string[] GetTimeZoneIds()
             {
-                return _ids;
+                int numTimeZoneIDs = 0;
+                for (int i = 0; i < _ids.Length; i++)
+                {
+                    if (!_isBackwards[i])
+                    {
+                        numTimeZoneIDs++;
+                    }
+                }
+                string[] nonBackwardsTZIDs = new string[numTimeZoneIDs];
+                var index = 0;
+                for (int i = 0; i < _ids.Length; i++)
+                {
+                    if (!_isBackwards[i])
+                    {
+                        nonBackwardsTZIDs[index] = _ids[i];
+                        index++;
+                    }
+                }
+                return nonBackwardsTZIDs;
             }
 
             public string GetTimeZoneDirectory()
diff --git a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
index fb7b8292b03f9d..e3e5bdd4564f30 100644
--- a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
+++ b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
@@ -2922,6 +2922,20 @@ public static void AdjustmentRuleBaseUtcOffsetDeltaTest()
             Assert.Equal(new TimeSpan(2, 0, 0), customTimeZone.GetUtcOffset(new DateTime(2021, 3, 10, 2, 0, 0)));
         }
 
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/64111", TestPlatforms.Linux)]
+        public static void NoBackwardTimeZones()
+        {
+            ReadOnlyCollection<TimeZoneInfo> tzCollection = TimeZoneInfo.GetSystemTimeZones();
+            HashSet<String> tzDisplayNames = new HashSet<String>();
+
+            foreach (TimeZoneInfo timezone in tzCollection)
+            {
+                tzDisplayNames.Add(timezone.DisplayName);
+            }
+            Assert.Equal(tzCollection.Count, tzDisplayNames.Count);
+        }
+
         private static bool IsEnglishUILanguage => CultureInfo.CurrentUICulture.Name.Length == 0 || CultureInfo.CurrentUICulture.TwoLetterISOLanguageName == "en";
 
         private static bool IsEnglishUILanguageAndRemoteExecutorSupported => IsEnglishUILanguage && RemoteExecutor.IsSupported;

From a5cf724aa2c9a67eb45827b56d6315acd4edea84 Mon Sep 17 00:00:00 2001
From: Santiago Fernandez Madero <safern@microsoft.com>
Date: Mon, 24 Jan 2022 17:28:03 -0800
Subject: [PATCH 049/161] Update main branding to preview2 (#64219)

---
 eng/Versions.props | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index 6484ee772cec7c..e9d607da85bfca 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -7,8 +7,8 @@
     <MinorVersion>0</MinorVersion>
     <PatchVersion>0</PatchVersion>
     <SdkBandVersion>7.0.100</SdkBandVersion>
-    <PreReleaseVersionLabel>alpha</PreReleaseVersionLabel>
-    <PreReleaseVersionIteration>1</PreReleaseVersionIteration>
+    <PreReleaseVersionLabel>preview</PreReleaseVersionLabel>
+    <PreReleaseVersionIteration>2</PreReleaseVersionIteration>
     <!-- Set assembly version to align with major and minor version,
          as for the patches and revisions should be manually updated per assembly if it is serviced. -->
     <AssemblyVersion>$(MajorVersion).$(MinorVersion).0.0</AssemblyVersion>

From 341c3941ad4065686f7a9f627b773b8e4e3c0999 Mon Sep 17 00:00:00 2001
From: Kunal Pathak <Kunal.Pathak@microsoft.com>
Date: Mon, 24 Jan 2022 21:49:56 -0800
Subject: [PATCH 050/161] Catch UnicodeEncodeErrors (#64251)

---
 src/coreclr/scripts/jitutil.py | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/coreclr/scripts/jitutil.py b/src/coreclr/scripts/jitutil.py
index 9552869dffa979..5df464da5fc0cb 100644
--- a/src/coreclr/scripts/jitutil.py
+++ b/src/coreclr/scripts/jitutil.py
@@ -85,12 +85,31 @@ def set_pipeline_variable(name, value):
     print(define_variable_format.format(name, value))  # set variable
 
 
+
 ################################################################################
 ##
 ## Helper functions
 ##
 ################################################################################
 
+def decode_string(str_to_decode):
+    """Decode a UTF-8 encoded bytes to string.
+
+    Args:
+        str_to_decode (byte stream): Byte stream to decode
+
+    Returns:
+        String output. If there any encoding/decoding errors, it will replace it with
+        UnicodeEncodeError.
+    """
+    try:
+        output = str_to_decode.decode("utf-8", errors='replace')
+    except UnicodeEncodeError:
+        output = "UnicodeEncodeError"
+    except UnicodeDecodeError:
+        output = "UnicodeDecodeError"
+    return output
+
 def run_command(command_to_run, _cwd=None, _exit_on_fail=False, _output_file=None):
     """ Runs the command.
 
@@ -119,15 +138,15 @@ def run_command(command_to_run, _cwd=None, _exit_on_fail=False, _output_file=Non
                     if proc.poll() is not None:
                         break
                     if output:
-                        output_str = output.strip().decode("utf-8", errors='replace')
+                        output_str = decode_string(output.strip())
                         print(output_str)
                         of.write(output_str + "\n")
         else:
             command_stdout, command_stderr = proc.communicate()
             if len(command_stdout) > 0:
-                print(command_stdout.decode("utf-8", errors='replace'))
+                print(decode_string(command_stdout))
             if len(command_stderr) > 0:
-                print(command_stderr.decode("utf-8", errors='replace'))
+                print(decode_string(command_stderr))
 
         return_code = proc.returncode
         if _exit_on_fail and return_code != 0:

From a5a645313d41332fcb6f90ece69c8c8738c5b93c Mon Sep 17 00:00:00 2001
From: Viktor Hofer <viktor.hofer@microsoft.com>
Date: Tue, 25 Jan 2022 08:15:27 +0100
Subject: [PATCH 051/161] Make XmlSerializer.Generator targets incremental
 (#64191)

* Make XmlSerializer.Generator targets incremental

Adding inputs and outputs to make XmlSerializer.Generator incremental
---
 .../src/GenerateNupkgProps.targets                          | 6 ++++--
 .../src/GenerateThisAssemblyCs.targets                      | 4 +++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateNupkgProps.targets b/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateNupkgProps.targets
index 6a402a0cfeb096..74fd8ebb92b2cd 100644
--- a/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateNupkgProps.targets
+++ b/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateNupkgProps.targets
@@ -10,7 +10,9 @@
           Pack="true" />
   </ItemGroup>
 
-  <Target Name="GenerateNupkgProps">
+  <Target Name="GenerateNupkgProps"
+          Inputs="$(MSBuildThisFileFullPath)"
+          Outputs="$(PropsFilePath)">
     <PropertyGroup>
       <PropsFileContents>
 &lt;Project&gt;
@@ -25,4 +27,4 @@
                       Lines="$(PropsFileContents)"
                       Overwrite="true" />
   </Target>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateThisAssemblyCs.targets b/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateThisAssemblyCs.targets
index 31fe16ae8c6f1a..aa5b94b12c7a6c 100644
--- a/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateThisAssemblyCs.targets
+++ b/src/libraries/Microsoft.XmlSerializer.Generator/src/GenerateThisAssemblyCs.targets
@@ -4,6 +4,8 @@
   </ItemGroup>
 
   <Target Name="GenerateThisAssemblyCs"
+          Inputs="$(MSBuildThisFileFullPath)"
+          Outputs="$(IntermediateOutputPath)ThisAssembly.cs"
           BeforeTargets="CoreCompile">
     <PropertyGroup>
       <ThisAssemblyCsContents>
@@ -44,6 +46,6 @@ namespace Microsoft.XmlSerializer.Generator
       File="$(IntermediateOutputPath)ThisAssembly.cs"
       Lines="$(ThisAssemblyCsContents)"
       Overwrite="true"
-      Encoding="Unicode"/>
+      Encoding="Unicode" />
   </Target>
 </Project>

From 9c938f726b7ca6d432114dae0504a5c164e8fbd6 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 25 Jan 2022 08:15:55 +0100
Subject: [PATCH 052/161] Make sure that shared memory object name meets the
 length requirements (#64099)

Co-authored-by: Stephen Toub <stoub@microsoft.com>
---
 .../MemoryMappedFile.Unix.cs                  | 52 +++++++++++++------
 .../tests/MemoryMappedFile.CreateNew.Tests.cs |  1 -
 .../tests/MemoryMappedViewAccessor.Tests.cs   |  1 -
 .../tests/MemoryMappedViewStream.Tests.cs     |  1 -
 .../MemoryMappedViewStreamConformanceTests.cs |  1 -
 src/native/libs/System.Native/pal_io.c        |  6 +++
 6 files changed, 42 insertions(+), 20 deletions(-)

diff --git a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs
index 389ab072d9a6c9..6882527cecc8de 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using Microsoft.Win32.SafeHandles;
 
 namespace System.IO.MemoryMappedFiles
@@ -173,9 +174,6 @@ private static FileStream CreateSharedBackingObject(Interop.Sys.MemoryMappedProt
         private static FileStream? CreateSharedBackingObjectUsingMemory(
            Interop.Sys.MemoryMappedProtections protections, long capacity, HandleInheritability inheritability)
         {
-            // The POSIX shared memory object name must begin with '/'.  After that we just want something short and unique.
-            string mapName = string.Create(null, stackalloc char[128], $"/corefx_map_{Guid.NewGuid():N}");
-
             // Determine the flags to use when creating the shared memory object
             Interop.Sys.OpenFlags flags = (protections & Interop.Sys.MemoryMappedProtections.PROT_WRITE) != 0 ?
                 Interop.Sys.OpenFlags.O_RDWR :
@@ -191,22 +189,32 @@ private static FileStream CreateSharedBackingObject(Interop.Sys.MemoryMappedProt
             if ((protections & Interop.Sys.MemoryMappedProtections.PROT_EXEC) != 0)
                 perms |= Interop.Sys.Permissions.S_IXUSR;
 
-            // Create the shared memory object.
-            SafeFileHandle fd = Interop.Sys.ShmOpen(mapName, flags, (int)perms);
-            if (fd.IsInvalid)
+            string mapName;
+            SafeFileHandle fd;
+
+            do
             {
-                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
-                if (errorInfo.Error == Interop.Error.ENOTSUP)
+                mapName = GenerateMapName();
+                fd = Interop.Sys.ShmOpen(mapName, flags, (int)perms); // Create the shared memory object.
+
+                if (fd.IsInvalid)
                 {
-                    // If ShmOpen is not supported, fall back to file backing object.
-                    // Note that the System.Native shim will force this failure on platforms where
-                    // the result of native shm_open does not work well with our subsequent call
-                    // to mmap.
-                    return null;
-                }
+                    Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+                    fd.Dispose();
 
-                throw Interop.GetExceptionForIoErrno(errorInfo);
-            }
+                    if (errorInfo.Error == Interop.Error.ENOTSUP)
+                    {
+                        // If ShmOpen is not supported, fall back to file backing object.
+                        // Note that the System.Native shim will force this failure on platforms where
+                        // the result of native shm_open does not work well with our subsequent call to mmap.
+                        return null;
+                    }
+                    else if (errorInfo.Error != Interop.Error.EEXIST) // map with same name already existed
+                    {
+                        throw Interop.GetExceptionForIoErrno(errorInfo);
+                    }
+                }
+            } while (fd.IsInvalid);
 
             try
             {
@@ -236,6 +244,18 @@ private static FileStream CreateSharedBackingObject(Interop.Sys.MemoryMappedProt
                 fd.Dispose();
                 throw;
             }
+
+            static string GenerateMapName()
+            {
+                const int MaxSharedMemoryObjectNameLength = 32; // SHM_NAME_MAX on OSX ARM64, on other systems it's equal PATH_MAX (250)
+                // The POSIX shared memory object name must begin with '/'.  After that we just want something short (32) and unique.
+                return string.Create(MaxSharedMemoryObjectNameLength, 0, (span, state) =>
+                {
+                    Guid.NewGuid().TryFormat(span, out int charsWritten, "N");
+                    Debug.Assert(charsWritten == MaxSharedMemoryObjectNameLength);
+                    "/dotnet_".CopyTo(span);
+                });
+            }
         }
 
         private static FileStream CreateSharedBackingObjectUsingFile(Interop.Sys.MemoryMappedProtections protections, long capacity, HandleInheritability inheritability)
diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateNew.Tests.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateNew.Tests.cs
index 4336ce74d6a223..70b82398301d56 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateNew.Tests.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateNew.Tests.cs
@@ -11,7 +11,6 @@ namespace System.IO.MemoryMappedFiles.Tests
     /// <summary>
     /// Tests for MemoryMappedFile.CreateNew.
     /// </summary>
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/63240", typeof(PlatformDetection), nameof(PlatformDetection.IsOSX), nameof(PlatformDetection.IsArm64Process), nameof(PlatformDetection.IsNotMonoRuntime))]
     public class MemoryMappedFileTests_CreateNew : MemoryMappedFilesTestBase
     {
         /// <summary>
diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewAccessor.Tests.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewAccessor.Tests.cs
index adcfb0e9d4cc42..8fe35396ae8044 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewAccessor.Tests.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewAccessor.Tests.cs
@@ -11,7 +11,6 @@ namespace System.IO.MemoryMappedFiles.Tests
     /// <summary>
     /// Tests for MemoryMappedViewAccessor.
     /// </summary>
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/63240", typeof(PlatformDetection), nameof(PlatformDetection.IsOSX), nameof(PlatformDetection.IsArm64Process), nameof(PlatformDetection.IsNotMonoRuntime))]
     public class MemoryMappedViewAccessorTests : MemoryMappedFilesTestBase
     {
         /// <summary>
diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStream.Tests.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStream.Tests.cs
index 3a950662e5d498..f279b8c33f98f7 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStream.Tests.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStream.Tests.cs
@@ -11,7 +11,6 @@ namespace System.IO.MemoryMappedFiles.Tests
     /// <summary>
     /// Tests for MemoryMappedViewStream.
     /// </summary>
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/63240", typeof(PlatformDetection), nameof(PlatformDetection.IsOSX), nameof(PlatformDetection.IsArm64Process), nameof(PlatformDetection.IsNotMonoRuntime))]
     public class MemoryMappedViewStreamTests : MemoryMappedFilesTestBase
     {
         /// <summary>
diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStreamConformanceTests.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStreamConformanceTests.cs
index 1ec0b14fb8a15e..c190d329a00fe6 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStreamConformanceTests.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedViewStreamConformanceTests.cs
@@ -45,7 +45,6 @@ private Task<Stream> CreateStream(byte[] initialData, FileAccess access)
         }
     }
 
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/63240", typeof(PlatformDetection), nameof(PlatformDetection.IsOSX), nameof(PlatformDetection.IsArm64Process), nameof(PlatformDetection.IsNotMonoRuntime))]
     public class AnonymousMemoryMappedViewStreamConformanceTests : MemoryMappedViewStreamConformanceTests
     {
         protected override MemoryMappedFile CreateFile(int length) =>
diff --git a/src/native/libs/System.Native/pal_io.c b/src/native/libs/System.Native/pal_io.c
index d11ce950f12460..f6cf0d2aa23eac 100644
--- a/src/native/libs/System.Native/pal_io.c
+++ b/src/native/libs/System.Native/pal_io.c
@@ -332,6 +332,12 @@ int32_t SystemNative_Unlink(const char* path)
 
 intptr_t SystemNative_ShmOpen(const char* name, int32_t flags, int32_t mode)
 {
+#if defined(SHM_NAME_MAX) // macOS
+    assert(strlen(name) <= SHM_NAME_MAX);
+#elif defined(PATH_MAX) // other Unixes
+    assert(strlen(name) <= PATH_MAX);
+#endif
+
 #if HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP
     flags = ConvertOpenFlags(flags);
     if (flags == -1)

From 0d1049fd11d2e2154ce852970cace53b4b296746 Mon Sep 17 00:00:00 2001
From: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date: Tue, 25 Jan 2022 12:00:20 +0200
Subject: [PATCH 053/161] Fix PAL_wprintf for wide characters (#64181)

---
 src/coreclr/pal/src/cruntime/printfcpp.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/coreclr/pal/src/cruntime/printfcpp.cpp b/src/coreclr/pal/src/cruntime/printfcpp.cpp
index d7e992c090a00b..fee79c91df12b4 100644
--- a/src/coreclr/pal/src/cruntime/printfcpp.cpp
+++ b/src/coreclr/pal/src/cruntime/printfcpp.cpp
@@ -86,7 +86,7 @@ static int Internal_Convertfwrite(CPalThread *pthrCurrent, const void *buffer, s
             free(newBuff);
             return -1;
         }
-        ret = InternalFwrite(newBuff, 1, count, stream, &iError);
+        ret = InternalFwrite(newBuff, 1, nsize, stream, &iError);
         if (iError != 0)
         {
             ERROR("InternalFwrite did not write the whole buffer. Error is %d\n", iError);

From 8d0c3d1ab1f16c3a1d15b8d9eb25cc920d936694 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Tue, 25 Jan 2022 12:11:58 +0100
Subject: [PATCH 054/161] [main] Update dependencies from dotnet/runtime
 dotnet/llvm-project (#64205)

* Update dependencies from https://github.com/dotnet/runtime build 20220123.5

Microsoft.NETCore.ILAsm , Microsoft.NETCore.DotNetHostPolicy , Microsoft.NETCore.DotNetHost , Microsoft.NETCore.App.Runtime.win-x64 , System.Runtime.CompilerServices.Unsafe , runtime.native.System.IO.Ports , Microsoft.NET.Sdk.IL , System.Text.Json
 From Version 7.0.0-alpha.1.22066.4 -> To Version 7.0.0-alpha.1.22073.5

* Update dependencies from https://github.com/dotnet/llvm-project build 20220123.1

runtime.win-x64.Microsoft.NETCore.Runtime.ObjWriter , runtime.win-arm64.Microsoft.NETCore.Runtime.ObjWriter , runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.ObjWriter , runtime.osx.11.0-arm64.Microsoft.NETCore.Runtime.ObjWriter , runtime.linux-x64.Microsoft.NETCore.Runtime.ObjWriter , runtime.linux-musl-x64.Microsoft.NETCore.Runtime.ObjWriter , runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.ObjWriter , runtime.linux-arm64.Microsoft.NETCore.Runtime.ObjWriter
 From Version 1.0.0-alpha.1.22070.1 -> To Version 1.0.0-alpha.1.22073.1

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
---
 eng/Version.Details.xml | 64 ++++++++++++++++++++---------------------
 eng/Versions.props      | 30 +++++++++----------
 global.json             |  2 +-
 3 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index ee709f74031a46..b01aa4c37ed5bd 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -16,37 +16,37 @@
       <Uri>https://github.com/dotnet/wcf</Uri>
       <Sha>7f504aabb1988e9a093c1e74d8040bd52feb2f01</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-musl-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.linux-musl-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
-    <Dependency Name="runtime.win-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.win-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
-    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
-    <Dependency Name="runtime.osx.11.0-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.osx.11.0-arm64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
-    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22070.1">
+    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.ObjWriter" Version="1.0.0-alpha.1.22073.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>fe77708023f3d8a51c1548b86487a692897227ec</Sha>
+      <Sha>afc9070f64d110ce2bf029a4a624b9dd1c6dbffd</Sha>
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
@@ -202,37 +202,37 @@
       <Uri>https://github.com/dotnet/llvm-project</Uri>
       <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.App.Runtime.win-x64" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="Microsoft.NETCore.App.Runtime.win-x64" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.DotNetHost" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="Microsoft.NETCore.DotNetHost" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.DotNetHostPolicy" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="Microsoft.NETCore.DotNetHostPolicy" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
-    <Dependency Name="runtime.native.System.IO.Ports" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="runtime.native.System.IO.Ports" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.ILAsm" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="Microsoft.NETCore.ILAsm" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NET.Sdk.IL" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="Microsoft.NET.Sdk.IL" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
-    <Dependency Name="System.Text.Json" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="System.Text.Json" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
-    <Dependency Name="System.Runtime.CompilerServices.Unsafe" Version="7.0.0-alpha.1.22066.4">
+    <Dependency Name="System.Runtime.CompilerServices.Unsafe" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>ae2f60c950cc021921fce83c796cbcb5ff96c658</Sha>
+      <Sha>09ff1acdad2e7789908b5db9bb89896144c13042</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NET.ILLink.Tasks" Version="7.0.100-1.22063.2">
       <Uri>https://github.com/dotnet/linker</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index e9d607da85bfca..535f0f7e4f01e4 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -72,20 +72,20 @@
     <!-- NuGet dependencies -->
     <NuGetBuildTasksPackVersion>6.0.0-preview.1.102</NuGetBuildTasksPackVersion>
     <!-- Installer dependencies -->
-    <MicrosoftNETCoreAppRuntimewinx64Version>7.0.0-alpha.1.22066.4</MicrosoftNETCoreAppRuntimewinx64Version>
-    <MicrosoftNETCoreDotNetHostVersion>7.0.0-alpha.1.22066.4</MicrosoftNETCoreDotNetHostVersion>
-    <MicrosoftNETCoreDotNetHostPolicyVersion>7.0.0-alpha.1.22066.4</MicrosoftNETCoreDotNetHostPolicyVersion>
+    <MicrosoftNETCoreAppRuntimewinx64Version>7.0.0-alpha.1.22073.5</MicrosoftNETCoreAppRuntimewinx64Version>
+    <MicrosoftNETCoreDotNetHostVersion>7.0.0-alpha.1.22073.5</MicrosoftNETCoreDotNetHostVersion>
+    <MicrosoftNETCoreDotNetHostPolicyVersion>7.0.0-alpha.1.22073.5</MicrosoftNETCoreDotNetHostPolicyVersion>
     <MicrosoftExtensionsDependencyModelVersion>3.1.0</MicrosoftExtensionsDependencyModelVersion>
     <!-- CoreClr dependencies -->
-    <MicrosoftNETCoreILAsmVersion>7.0.0-alpha.1.22066.4</MicrosoftNETCoreILAsmVersion>
-    <runtimelinuxarm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimelinuxarm64MicrosoftNETCoreRuntimeObjWriterVersion>
-    <runtimelinuxx64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimelinuxx64MicrosoftNETCoreRuntimeObjWriterVersion>
-    <runtimelinuxmuslarm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimelinuxmuslarm64MicrosoftNETCoreRuntimeObjWriterVersion>
-    <runtimelinuxmuslx64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimelinuxmuslx64MicrosoftNETCoreRuntimeObjWriterVersion>
-    <runtimewinarm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimewinarm64MicrosoftNETCoreRuntimeObjWriterVersion>
-    <runtimewinx64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimewinx64MicrosoftNETCoreRuntimeObjWriterVersion>
-    <runtimeosx110arm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimeosx110arm64MicrosoftNETCoreRuntimeObjWriterVersion>
-    <runtimeosx1012x64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22070.1</runtimeosx1012x64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <MicrosoftNETCoreILAsmVersion>7.0.0-alpha.1.22073.5</MicrosoftNETCoreILAsmVersion>
+    <runtimelinuxarm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimelinuxarm64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <runtimelinuxx64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimelinuxx64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <runtimelinuxmuslarm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimelinuxmuslarm64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <runtimelinuxmuslx64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimelinuxmuslx64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <runtimewinarm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimewinarm64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <runtimewinx64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimewinx64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <runtimeosx110arm64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimeosx110arm64MicrosoftNETCoreRuntimeObjWriterVersion>
+    <runtimeosx1012x64MicrosoftNETCoreRuntimeObjWriterVersion>1.0.0-alpha.1.22073.1</runtimeosx1012x64MicrosoftNETCoreRuntimeObjWriterVersion>
     <!-- Libraries dependencies -->
     <MicrosoftBclAsyncInterfacesVersion>5.0.0</MicrosoftBclAsyncInterfacesVersion>
     <MicrosoftWin32PrimitivesVersion>4.3.0</MicrosoftWin32PrimitivesVersion>
@@ -120,11 +120,11 @@
     <SystemSecurityCryptographyOpenSslVersion>5.0.0</SystemSecurityCryptographyOpenSslVersion>
     <SystemSecurityPrincipalWindowsVersion>5.0.0</SystemSecurityPrincipalWindowsVersion>
     <SystemServiceModelPrimitivesVersion>4.9.0-rc2.21473.1</SystemServiceModelPrimitivesVersion>
-    <SystemTextJsonVersion>7.0.0-alpha.1.22066.4</SystemTextJsonVersion>
-    <SystemRuntimeCompilerServicesUnsafeVersion>7.0.0-alpha.1.22066.4</SystemRuntimeCompilerServicesUnsafeVersion>
+    <SystemTextJsonVersion>7.0.0-alpha.1.22073.5</SystemTextJsonVersion>
+    <SystemRuntimeCompilerServicesUnsafeVersion>7.0.0-alpha.1.22073.5</SystemRuntimeCompilerServicesUnsafeVersion>
     <SystemThreadingTasksExtensionsVersion>4.5.4</SystemThreadingTasksExtensionsVersion>
     <SystemValueTupleVersion>4.5.0</SystemValueTupleVersion>
-    <runtimenativeSystemIOPortsVersion>7.0.0-alpha.1.22066.4</runtimenativeSystemIOPortsVersion>
+    <runtimenativeSystemIOPortsVersion>7.0.0-alpha.1.22073.5</runtimenativeSystemIOPortsVersion>
     <!-- Runtime-Assets dependencies -->
     <SystemRuntimeNumericsTestDataVersion>7.0.0-beta.22060.1</SystemRuntimeNumericsTestDataVersion>
     <SystemComponentModelTypeConverterTestDataVersion>7.0.0-beta.22060.1</SystemComponentModelTypeConverterTestDataVersion>
diff --git a/global.json b/global.json
index e0d86ef423d93f..f32ffc29ff09d7 100644
--- a/global.json
+++ b/global.json
@@ -18,6 +18,6 @@
     "Microsoft.DotNet.SharedFramework.Sdk": "7.0.0-beta.22071.6",
     "Microsoft.Build.NoTargets": "3.1.0",
     "Microsoft.Build.Traversal": "3.0.23",
-    "Microsoft.NET.Sdk.IL": "7.0.0-alpha.1.22066.4"
+    "Microsoft.NET.Sdk.IL": "7.0.0-alpha.1.22073.5"
   }
 }

From 4d16d0934259b2b1b056823986bb0ad08578c5c0 Mon Sep 17 00:00:00 2001
From: Viktor Hofer <viktor.hofer@microsoft.com>
Date: Tue, 25 Jan 2022 13:09:57 +0100
Subject: [PATCH 055/161] Delete unused ApiCompat baseline files (#64190)

* Delete unused ApiCompat baseline files

* Delete ApiCompatBaseline.netfx.netstandardOnly.txt

* Remove manual .NETFramework baseline validation

* Delete ApiCompatBaseline.netcoreapp.netfx461.ignore.txt

* Delete ApiCompatBaseline.netcoreapp.netfx461.txt
---
 src/libraries/shims/ApiCompat.proj            |   20 +-
 ...patBaseline.netcoreapp.netfx461.ignore.txt | 2709 -----------------
 .../ApiCompatBaseline.netcoreapp.netfx461.txt |  614 ----
 .../ApiCompatBaseline.netfx.netstandard.txt   |  102 -
 ...piCompatBaseline.netfx.netstandardOnly.txt |  870 ------
 5 files changed, 1 insertion(+), 4314 deletions(-)
 delete mode 100644 src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.ignore.txt
 delete mode 100644 src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.txt
 delete mode 100644 src/libraries/shims/ApiCompatBaseline.netfx.netstandard.txt
 delete mode 100644 src/libraries/shims/ApiCompatBaseline.netfx.netstandardOnly.txt

diff --git a/src/libraries/shims/ApiCompat.proj b/src/libraries/shims/ApiCompat.proj
index 3b2c6ceae57c06..e27786ccb1a54c 100644
--- a/src/libraries/shims/ApiCompat.proj
+++ b/src/libraries/shims/ApiCompat.proj
@@ -1,12 +1,5 @@
 <Project Sdk="Microsoft.Build.NoTargets">
 
-  <!-- Run API compat against the following 1:1 assemblies but don't include them in the list that is used to generate facades -->
-  <ItemGroup>
-    <NetFxReference Include="System.DirectoryServices" />
-    <NetFxReference Include="System.DirectoryServices.AccountManagement" />
-    <NetFxReference Include="System.DirectoryServices.Protocols" />
-  </ItemGroup>
-
   <ItemGroup>
     <PackageDownload Include="Microsoft.NETCore.App.Ref" Version="[$(NetCoreAppLatestStablePackageBaselineVersion)]" />
     <PackageDownload Include="NETStandard.Library.Ref" Version="[$(NETStandardLibraryRefVersion)]" />
@@ -16,8 +9,6 @@
 
   <Target Name="GetApiCompatInputsAndOutputs">
     <PropertyGroup>
-      <ApiCompatBaselineFile>$(MSBuildThisFileDirectory)ApiCompatBaseline.netcoreapp.netfx461.txt</ApiCompatBaselineFile>
-      <ApiCompatBaselineIgnoreFile>$(MSBuildThisFileDirectory)ApiCompatBaseline.netcoreapp.netfx461.ignore.txt</ApiCompatBaselineIgnoreFile>
       <ApiCompatNSBaselineFile>$(MSBuildThisFileDirectory)ApiCompatBaseline.netcoreapp.netstandard.txt</ApiCompatNSBaselineFile>
       <ApiCompatNSOnlyBaselineFile>$(MSBuildThisFileDirectory)ApiCompatBaseline.netcoreapp.netstandardOnly.txt</ApiCompatNSOnlyBaselineFile>
       <PreviousNetCoreAppBaselineFile>$(MSBuildThisFileDirectory)ApiCompatBaseline.PreviousNetCoreApp.txt</PreviousNetCoreAppBaselineFile>
@@ -32,7 +23,7 @@
   <Target Name="RunApiCompat"
           DependsOnTargets="GetApiCompatInputsAndOutputs"
           AfterTargets="Build"
-          Inputs="@(NetCoreAppCurrentRefFile);$(ApiCompatBaselineFile);$(ApiCompatBaselineIgnoreFile);$(ApiCompatNSBaselineFile);$(ApiCompatNSOnlyBaselineFile);$(PreviousNetCoreAppBaselineFile)"
+          Inputs="@(NetCoreAppCurrentRefFile);$(ApiCompatNSBaselineFile);$(ApiCompatNSOnlyBaselineFile);$(PreviousNetCoreAppBaselineFile)"
           Outputs="$(ApiCompatMarkerFile)">
 
     <PropertyGroup>
@@ -46,15 +37,6 @@
                       Lines="$(ApiCompatArgs)"
                       Overwrite="true" />
 
-    <Exec Command="$(_ApiCompatCommand) &quot;@(NetFxReference -> '$(NetFxRefPath)%(Identity).dll')&quot; --baseline &quot;$(ApiCompatBaselineIgnoreFile)&quot; @&quot;$(ApiCompatResponseFile)&quot; &gt; $(ApiCompatBaselineFile)"
-          Condition="'$(BaselineApiCompat)' == 'true'"
-          CustomErrorRegularExpression="^[a-zA-Z]+ :"
-          StandardOutputImportance="Low"
-          IgnoreExitCode="true">
-      <Output TaskParameter="ExitCode" PropertyName="ApiCompatExitCode" />
-    </Exec>
-    <Error Condition="'$(ApiCompatExitCode)' != '0'" Text="ApiCompat failed comparing $(NETFrameworkReferenceAssemblyTFM) to $(NetCoreAppCurrent)" />
-
     <!-- In order to update the .NETStandard baseline, you can just start the build with /p:UpdateNETStandardBaseline=true -->
     <PropertyGroup>
       <NetStandardLibrary20RefPath>$([MSBuild]::NormalizeDirectory('$(NuGetPackageRoot)', 'netstandard.library', '$(NetStandardLibraryVersion)', 'build', 'netstandard2.0', 'ref'))</NetStandardLibrary20RefPath>
diff --git a/src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.ignore.txt b/src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.ignore.txt
deleted file mode 100644
index b0420059f5aae9..00000000000000
--- a/src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.ignore.txt
+++ /dev/null
@@ -1,2709 +0,0 @@
-// HttpVersion changed to static class intentionally. See here: https://github.com/dotnet/standard/issues/91
-CannotMakeTypeAbstract : Type 'System.Net.HttpVersion' is abstract in the implementation but is not abstract in the contract.
-CannotSealType : Type 'System.Net.HttpVersion' is sealed in the implementation but not sealed in the contract.
-MembersMustExist : Member 'System.Net.HttpVersion..ctor()' does not exist in the implementation but it does exist in the contract.
-
-// RuntimeEnvironment changed to static class intentionally. See here: https://github.com/dotnet/standard/commit/d5fbcbeeeb7f15102fdac111bc8d7d5d72c32036#diff-2856a41639a1f4feb4e95ae667e069b7R10012
-CannotMakeTypeAbstract : Type 'System.Runtime.InteropServices.RuntimeEnvironment' is abstract in the implementation but is not abstract in the contract.
-CannotSealType : Type 'System.Runtime.InteropServices.RuntimeEnvironment' is sealed in the implementation but not sealed in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.RuntimeEnvironment..ctor()' does not exist in the implementation but it does exist in the contract.
-
-// Activator changed to static class intentionally. See here: https://github.com/dotnet/runtime/issues/18630
-CannotMakeTypeAbstract : Type 'System.Activator' is abstract in the implementation but is not abstract in the contract.
-
-// System.Drawing types changed to static intentionally.  Change is source and binary compatible.  https://github.com/dotnet/corefx/commit/ad215be2fa28a7d2f19a90c1ba04c50c3b677253
-CannotMakeTypeAbstract : Type 'System.Drawing.Brushes' is abstract in the implementation but is not abstract in the contract.
-CannotMakeTypeAbstract : Type 'System.Drawing.Pens' is abstract in the implementation but is not abstract in the contract.
-CannotMakeTypeAbstract : Type 'System.Drawing.SystemBrushes' is abstract in the implementation but is not abstract in the contract.
-CannotMakeTypeAbstract : Type 'System.Drawing.SystemColors' is abstract in the implementation but is not abstract in the contract.
-CannotMakeTypeAbstract : Type 'System.Drawing.SystemFonts' is abstract in the implementation but is not abstract in the contract.
-CannotMakeTypeAbstract : Type 'System.Drawing.SystemIcons' is abstract in the implementation but is not abstract in the contract.
-CannotMakeTypeAbstract : Type 'System.Drawing.SystemPens' is abstract in the implementation but is not abstract in the contract.
-CannotMakeTypeAbstract : Type 'System.Drawing.BufferedGraphicsManager' is abstract in the implementation but is not abstract in the contract.
-
-// Won't came back into netcoreapp. See here: https://github.com/dotnet/runtime/issues/20974
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.ValidationContext.ServiceContainer.get()' does not exist in the implementation but it does exist in the contract.
-
-// Debugger changed to static class intentionally. See here: https://github.com/dotnet/standard/commit/d5fbcbeeeb7f15102fdac111bc8d7d5d72c32036#diff-2856a41639a1f4feb4e95ae667e069b7R10012
-CannotMakeTypeAbstract : Type 'System.Diagnostics.Debugger' is abstract in the implementation but is not abstract in the contract.
-MembersMustExist : Member 'System.Diagnostics.Debugger..ctor()' does not exist in the implementation but it does exist in the contract.
-
-// IRemotingFormatter won't be implemented in netcore20
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter' does not implement interface 'System.Runtime.Remoting.Messaging.IRemotingFormatter' in the implementation but it does in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.IRemotingFormatter' does not exist in the implementation but it does exist in the contract.
-
-// SchemaImporter won't be implemented in netcore20
-TypesMustExist : Type 'System.Xml.Serialization.SchemaImporter' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlSchemaImporter' does not inherit from base type 'System.Xml.Serialization.SchemaImporter' in the implementation but it does in the contract.
-
-// IServiceProvider won't be implemented by SqlClientFactory. See here: https://github.com/dotnet/runtime/issues/20832
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlClient.SqlClientFactory' does not implement interface 'System.IServiceProvider' in the implementation but it does in the contract.
-
-// DynData Win9x only. Not going to be implemented in any netcore versions. See here: https://github.com/dotnet/runtime/issues/19972
-MembersMustExist : Member 'Microsoft.Win32.RegistryKey Microsoft.Win32.Registry.DynData' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'Microsoft.Win32.RegistryHive Microsoft.Win32.RegistryHive.DynData' does not exist in the implementation but it does exist in the contract.
-
-// AppDomain.SetupInformation not going to be implemented in netcore20 as no remoting support:
-MembersMustExist : Member 'System.AppDomain.SetupInformation.get()' does not exist in the implementation but it does exist in the contract.
-
-// SetAccessControl in FileStream not going to be implemented in netcore20 as no ACL support:
-MembersMustExist : Member 'System.IO.FileStream.SetAccessControl(System.Security.AccessControl.FileSecurity)' does not exist in the implementation but it does exist in the contract.
-
-// StackTrace ctor deprecated in net472 and won't be implemented in any netcoreapp versions:
-MembersMustExist : Member 'System.Diagnostics.StackTrace..ctor(System.Threading.Thread, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-
-// Dan said there is a reason for those in System.Resrouces to ignore:
-MembersMustExist : Member 'System.String System.Resources.ResourceManager.BaseNameField' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Hashtable System.Resources.ResourceSet.Table' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Resources.IResourceReader System.Resources.ResourceSet.Reader' does not exist in the implementation but it does exist in the contract.
-
-// Thread.CurrentContext is not supported because of remoting:
-MembersMustExist : Member 'System.Threading.Thread.CurrentContext.get()' does not exist in the implementation but it does exist in the contract.
-
-// Debug.Listeners won't be implemented in netstandard20 and netcoreapp20. See here: https://github.com/dotnet/standard/issues/84
-MembersMustExist : Member 'System.Diagnostics.Debug.Listeners.get()' does not exist in the implementation but it does exist in the contract.
-
-// IsolatedStorage methods won't be implemented in netstandard20 and netcoreapp20. See here: https://github.com/dotnet/runtime/issues/20970
-MembersMustExist : Member 'System.IO.IsolatedStorage.IsolatedStorage.GetPermission(System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.IsolatedStorage.IsolatedStorageFile.GetPermission(System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.IsolatedStorage.IsolatedStorageFile.GetStore(System.IO.IsolatedStorage.IsolatedStorageScope, System.Security.Policy.Evidence, System.Type, System.Security.Policy.Evidence, System.Type)' does not exist in the implementation but it does exist in the contract.
-
-// Crypto types and members are sealed in netstandard and netcoreapp because they are sealed in Xamarin. https://github.com/dotnet/runtime/issues/20870
-CannotSealType : Type 'System.Security.Cryptography.SHA1Managed' is sealed in the implementation but not sealed in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA1Managed.HashCore(System.Byte[], System.Int32, System.Int32)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA1Managed.HashFinal()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA1Managed.Initialize()' is non-virtual in the implementation but is virtual in the contract.
-CannotSealType : Type 'System.Security.Cryptography.SHA256Managed' is sealed in the implementation but not sealed in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA256Managed.HashCore(System.Byte[], System.Int32, System.Int32)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA256Managed.HashFinal()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA256Managed.Initialize()' is non-virtual in the implementation but is virtual in the contract.
-CannotSealType : Type 'System.Security.Cryptography.SHA384Managed' is sealed in the implementation but not sealed in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA384Managed.HashCore(System.Byte[], System.Int32, System.Int32)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA384Managed.HashFinal()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA384Managed.Initialize()' is non-virtual in the implementation but is virtual in the contract.
-CannotSealType : Type 'System.Security.Cryptography.SHA512Managed' is sealed in the implementation but not sealed in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA512Managed.HashCore(System.Byte[], System.Int32, System.Int32)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA512Managed.HashFinal()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Security.Cryptography.SHA512Managed.Initialize()' is non-virtual in the implementation but is virtual in the contract.
-
-// Can't build WindowsIdentities or WindowsPrincipals on non-Windows OSes. https://github.com/dotnet/runtime/issues/20972
-MembersMustExist : Member 'System.Security.Principal.IdentityReferenceCollection.IsReadOnly.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsIdentity..ctor(System.Security.Principal.WindowsIdentity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsIdentity..ctor(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsIdentity.DeviceClaims.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsIdentity.Impersonate()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsIdentity.Impersonate(System.IntPtr)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsIdentity.UserClaims.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsPrincipal.DeviceClaims.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WindowsPrincipal.UserClaims.get()' does not exist in the implementation but it does exist in the contract.
-
-// Reflection.Emit future unclear and won't be implemented till netcoreapp20. See here: https://github.com/dotnet/runtime/issues/20971
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.AddResourceFile(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.AddResourceFile(System.String, System.String, System.Reflection.ResourceAttributes)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineDynamicModule(System.String, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineDynamicModule(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineDynamicModule(System.String, System.String, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineResource(System.String, System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineResource(System.String, System.String, System.String, System.Reflection.ResourceAttributes)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineUnmanagedResource(System.Byte[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineUnmanagedResource(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineVersionInfoResource()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.DefineVersionInfoResource(System.String, System.String, System.String, System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.Evidence.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.PermissionSet.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.Save(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.Save(System.String, System.Reflection.PortableExecutableKinds, System.Reflection.ImageFileMachine)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.SetEntryPoint(System.Reflection.MethodInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilder.SetEntryPoint(System.Reflection.MethodInfo, System.Reflection.Emit.PEFileKinds)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilderAccess System.Reflection.Emit.AssemblyBuilderAccess.ReflectionOnly' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilderAccess System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.AssemblyBuilderAccess System.Reflection.Emit.AssemblyBuilderAccess.Save' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ConstructorBuilder.AddDeclarativeSecurity(System.Security.Permissions.SecurityAction, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ConstructorBuilder.GetModule()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ConstructorBuilder.GetToken()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ConstructorBuilder.ReturnType.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ConstructorBuilder.SetMethodBody(System.Byte[], System.Int32, System.Byte[], System.Collections.Generic.IEnumerable<System.Reflection.Emit.ExceptionHandler>, System.Collections.Generic.IEnumerable<System.Int32>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ConstructorBuilder.SetSymCustomAttribute(System.String, System.Byte[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ConstructorBuilder.Signature.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.EnumBuilder.CreateType()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.EnumBuilder.TypeToken.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.EventBuilder.GetEventToken()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.FieldBuilder.GetToken()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.FieldBuilder.SetMarshal(System.Reflection.Emit.UnmanagedMarshal)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ILGenerator.EmitCalli(System.Reflection.Emit.OpCode, System.Runtime.InteropServices.CallingConvention, System.Type, System.Type[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ILGenerator.MarkSequencePoint(System.Diagnostics.SymbolStore.ISymbolDocumentWriter, System.Int32, System.Int32, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.AddDeclarativeSecurity(System.Security.Permissions.SecurityAction, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.CreateMethodBody(System.Byte[], System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.GetModule()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.GetToken()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.SetMarshal(System.Reflection.Emit.UnmanagedMarshal)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.SetMethodBody(System.Byte[], System.Int32, System.Byte[], System.Collections.Generic.IEnumerable<System.Reflection.Emit.ExceptionHandler>, System.Collections.Generic.IEnumerable<System.Int32>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.SetSymCustomAttribute(System.String, System.Byte[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.MethodBuilder.Signature.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefineDocument(System.String, System.Guid, System.Guid, System.Guid)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefineManifestResource(System.String, System.IO.Stream, System.Reflection.ResourceAttributes)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefinePInvokeMethod(System.String, System.String, System.Reflection.MethodAttributes, System.Reflection.CallingConventions, System.Type, System.Type[], System.Runtime.InteropServices.CallingConvention, System.Runtime.InteropServices.CharSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefinePInvokeMethod(System.String, System.String, System.String, System.Reflection.MethodAttributes, System.Reflection.CallingConventions, System.Type, System.Type[], System.Runtime.InteropServices.CallingConvention, System.Runtime.InteropServices.CharSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefineResource(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefineResource(System.String, System.String, System.Reflection.ResourceAttributes)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefineUnmanagedResource(System.Byte[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.DefineUnmanagedResource(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetArrayMethodToken(System.Type, System.String, System.Reflection.CallingConventions, System.Type, System.Type[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetConstructorToken(System.Reflection.ConstructorInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetConstructorToken(System.Reflection.ConstructorInfo, System.Collections.Generic.IEnumerable<System.Type>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetFieldToken(System.Reflection.FieldInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetMethodToken(System.Reflection.MethodInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetMethodToken(System.Reflection.MethodInfo, System.Collections.Generic.IEnumerable<System.Type>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetSignatureToken(System.Byte[], System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetSignatureToken(System.Reflection.Emit.SignatureHelper)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetSignerCertificate()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetStringConstant(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetSymWriter()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetTypeToken(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.GetTypeToken(System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.IsTransient()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.SetSymCustomAttribute(System.String, System.Byte[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ModuleBuilder.SetUserEntryPoint(System.Reflection.MethodInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ParameterBuilder.GetToken()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.ParameterBuilder.SetMarshal(System.Reflection.Emit.UnmanagedMarshal)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.PropertyBuilder.PropertyToken.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.SignatureHelper.GetMethodSigHelper(System.Reflection.Module, System.Runtime.InteropServices.CallingConvention, System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.SignatureHelper.GetMethodSigHelper(System.Runtime.InteropServices.CallingConvention, System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.TypeBuilder.AddDeclarativeSecurity(System.Security.Permissions.SecurityAction, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.TypeBuilder.DefinePInvokeMethod(System.String, System.String, System.Reflection.MethodAttributes, System.Reflection.CallingConventions, System.Type, System.Type[], System.Runtime.InteropServices.CallingConvention, System.Runtime.InteropServices.CharSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.TypeBuilder.DefinePInvokeMethod(System.String, System.String, System.String, System.Reflection.MethodAttributes, System.Reflection.CallingConventions, System.Type, System.Type[], System.Runtime.InteropServices.CallingConvention, System.Runtime.InteropServices.CharSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.TypeBuilder.DefinePInvokeMethod(System.String, System.String, System.String, System.Reflection.MethodAttributes, System.Reflection.CallingConventions, System.Type, System.Type[], System.Type[], System.Type[], System.Type[][], System.Type[][], System.Runtime.InteropServices.CallingConvention, System.Runtime.InteropServices.CharSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Emit.TypeBuilder.TypeToken.get()' does not exist in the implementation but it does exist in the contract.
-
-// Consciously are not bringing to core
-TypesMustExist : Type 'System.Security.Cryptography.CryptoAPITransform' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.HMACRIPEMD160' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.MACTripleDES' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.RijndaelManagedTransform' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.RIPEMD160' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.RIPEMD160Managed' does not exist in the implementation but it does exist in the contract.
-
-// Too coupled to ACLs
-TypesMustExist : Type 'System.Security.AccessControl.CryptoKeyAccessRule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.AccessControl.CryptoKeyAuditRule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.AccessControl.CryptoKeyRights' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.AccessControl.CryptoKeySecurity' does not exist in the implementation but it does exist in the contract.
-
-// Interfaces were intentional removals
-CannotRemoveBaseTypeOrInterface : Type 'System.Windows.Markup.ValueSerializerAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.DirectoryServicesCOMException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ServiceProcess.ServiceControllerPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ServiceProcess.ServiceProcessDescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'Microsoft.SqlServer.Server.SqlMethodAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'Microsoft.SqlServer.Server.SqlUserDefinedAggregateAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'Microsoft.SqlServer.Server.SqlUserDefinedTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.RegexStringValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Text.RegularExpressions.RegexMatchTimeoutException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'Microsoft.SqlServer.Server.InvalidUdtException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'Microsoft.SqlServer.Server.SqlFunctionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ServiceProcess.TimeoutException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.NetworkInformation.PingException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.AccessViolationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Activator' does not implement interface 'System.Runtime.InteropServices._Activator' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.AggregateException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.AppDomain' does not implement interface 'System._AppDomain' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DataMisalignedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DivideByZeroException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DllNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DuplicateWaitObjectException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.EntryPointNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Exception' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ExecutionEngineException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.FieldAccessException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.FlagsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.FormatException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.AppDomainUnloadedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ApplicationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ArgumentException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ArgumentNullException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ArgumentOutOfRangeException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ArithmeticException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ArrayTypeMismatchException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Attribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.AttributeUsageAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.BadImageFormatException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.CannotUnloadAppDomainException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.CLSCompliantAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ContextMarshalException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ContextStaticAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IndexOutOfRangeException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.InsufficientExecutionStackException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.InsufficientMemoryException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.InvalidCastException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.InvalidOperationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.InvalidProgramException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.InvalidTimeZoneException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.LoaderOptimizationAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.MemberAccessException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.MethodAccessException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.MissingFieldException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.MissingMemberException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.MissingMethodException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.MTAThreadAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.MulticastNotSupportedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.NonSerializedAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.NotFiniteNumberException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.NotImplementedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.NotSupportedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.NullReferenceException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ObjectDisposedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ObsoleteAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.OperationCanceledException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.OutOfMemoryException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.OverflowException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ParamArrayAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.PlatformNotSupportedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.RankException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.SerializableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.StackOverflowException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.STAThreadAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.SystemException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ThreadStaticAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.TimeoutException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.TimeZoneNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Type' does not implement interface 'System.Runtime.InteropServices._Type' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.TypeAccessException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.TypeInitializationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.TypeLoadException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.TypeUnloadedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.UnauthorizedAccessException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Collections.Generic.KeyNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.ConditionalAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerBrowsableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerDisplayAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerHiddenAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerNonUserCodeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerStepperBoundaryAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerStepThroughAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerTypeProxyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.DebuggerVisualizerAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.CodeAnalysis.SuppressMessageAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractAbbreviatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractArgumentValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractClassAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractClassForAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractInvariantMethodAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractOptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractPublicPropertyNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractReferenceAssemblyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractRuntimeIgnoredAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.ContractVerificationAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Contracts.PureAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.EventAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.EventDataAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.EventFieldAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.EventIgnoreAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.EventSourceAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.EventSourceException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.NonEventAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Globalization.CultureNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.DirectoryNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.DriveNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.EndOfStreamException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.FileLoadException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.FileNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.IOException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.PathTooLongException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.IsolatedStorage.IsolatedStorageException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AmbiguousMatchException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Assembly' does not implement interface 'System.Runtime.InteropServices._Assembly' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyAlgorithmIdAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyCompanyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyConfigurationAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyCopyrightAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyCultureAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyDefaultAliasAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyDelaySignAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyDescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyFileVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyFlagsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyInformationalVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyKeyFileAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyKeyNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyMetadataAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyName' does not implement interface 'System.Runtime.InteropServices._AssemblyName' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyProductAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblySignatureKeyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyTitleAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyTrademarkAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.AssemblyVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.ConstructorInfo' does not implement interface 'System.Runtime.InteropServices._ConstructorInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.CustomAttributeFormatException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.DefaultMemberAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.EventInfo' does not implement interface 'System.Runtime.InteropServices._EventInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.FieldInfo' does not implement interface 'System.Runtime.InteropServices._FieldInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.InvalidFilterCriteriaException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.MemberInfo' does not implement interface 'System.Runtime.InteropServices._MemberInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.MethodBase' does not implement interface 'System.Runtime.InteropServices._MethodBase' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.MethodInfo' does not implement interface 'System.Runtime.InteropServices._MethodInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Module' does not implement interface 'System.Runtime.InteropServices._Module' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.ObfuscateAssemblyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.ObfuscationAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.ParameterInfo' does not implement interface 'System.Runtime.InteropServices._ParameterInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.PropertyInfo' does not implement interface 'System.Runtime.InteropServices._PropertyInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.ReflectionTypeLoadException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.TargetException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.TargetInvocationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.TargetParameterCountException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.TypeDelegator' does not implement interface 'System.Runtime.InteropServices._Type' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.TypeInfo' does not implement interface 'System.Runtime.InteropServices._Type' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.AssemblyBuilder' does not implement interface 'System.Runtime.InteropServices._AssemblyBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.ConstructorBuilder' does not implement interface 'System.Runtime.InteropServices._ConstructorBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.CustomAttributeBuilder' does not implement interface 'System.Runtime.InteropServices._CustomAttributeBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.DynamicMethod' does not implement interface 'System.Runtime.InteropServices._MethodInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.EventBuilder' does not implement interface 'System.Runtime.InteropServices._EventBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.FieldBuilder' does not implement interface 'System.Runtime.InteropServices._FieldBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.ILGenerator' does not implement interface 'System.Runtime.InteropServices._ILGenerator' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.LocalBuilder' does not implement interface 'System.Runtime.InteropServices._LocalBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.MethodBuilder' does not implement interface 'System.Runtime.InteropServices._MethodBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.ModuleBuilder' does not implement interface 'System.Runtime.InteropServices._ModuleBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.ParameterBuilder' does not implement interface 'System.Runtime.InteropServices._ParameterBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.PropertyBuilder' does not implement interface 'System.Runtime.InteropServices._PropertyBuilder' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.SignatureHelper' does not implement interface 'System.Runtime.InteropServices._SignatureHelper' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Resources.MissingManifestResourceException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Resources.MissingSatelliteAssemblyException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Resources.NeutralResourcesLanguageAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Resources.SatelliteContractVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.AssemblyTargetedPatchBandAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.TargetedPatchingOptOutAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.AccessedThroughPropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.AsyncStateMachineAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.CallerFilePathAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.CallerLineNumberAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.CallerMemberNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.CompilationRelaxationsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.CompilerGeneratedAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.CompilerGlobalScopeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.CustomConstantAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.DateTimeConstantAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.DecimalConstantAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.DefaultDependencyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.DependencyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.DisablePrivateReflectionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.DiscardableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.ExtensionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.FixedAddressValueTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.FixedBufferAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.HasCopySemanticsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.IndexerNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.InternalsVisibleToAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.IteratorStateMachineAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.IUnknownConstantAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.MethodImplAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.NativeCppClassAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.ReferenceAssemblyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.RequiredAttributeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.RuntimeCompatibilityAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.RuntimeWrappedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.ScopelessEnumAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.SpecialNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.StateMachineAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.StringFreezingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.SuppressIldasmAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.TypeForwardedFromAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.TypeForwardedToAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.UnsafeValueTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.ConstrainedExecution.PrePrepareMethodAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.ConstrainedExecution.ReliabilityContractAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.AllowReversePInvokeCallsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.AutomationProxyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.BestFitMappingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ClassInterfaceAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.CoClassAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComAliasNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComCompatibleVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComConversionLossAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComDefaultInterfaceAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComEventInterfaceAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.COMException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComImportAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComRegisterFunctionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComSourceInterfacesAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComUnregisterFunctionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComVisibleAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.DefaultCharSetAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.DefaultDllImportSearchPathsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.DispIdAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.DllImportAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ExternalException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.FieldOffsetAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.GuidAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.InAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.InterfaceTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.InvalidComObjectException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.InvalidOleVariantTypeException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.LCIDConversionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ManagedToNativeComInteropStubAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.MarshalAsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.MarshalDirectiveException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.OptionalAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.OutAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.PreserveSigAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ProgIdAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.SafeArrayRankMismatchException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.SafeArrayTypeMismatchException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.SEHException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.StructLayoutAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.TypeIdentifierAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.UnmanagedFunctionPointerAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.WindowsRuntime.DefaultInterfaceAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.WindowsRuntime.InterfaceImplementedInVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.WindowsRuntime.ReadOnlyArrayAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.WindowsRuntime.ReturnValueNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.WindowsRuntime.WriteOnlyArrayAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.OnDeserializedAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.OnDeserializingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.OnSerializedAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.OnSerializingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.OptionalFieldAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.SerializationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter' does not implement interface 'System.Runtime.Remoting.Messaging.IRemotingFormatter' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Versioning.ComponentGuaranteesAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Versioning.ResourceConsumptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Versioning.ResourceExposureAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Versioning.TargetFrameworkAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.AllowPartiallyTrustedCallersAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.HostProtectionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.SecurityCriticalAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.SecurityException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.SecurityRulesAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.SecuritySafeCriticalAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.SecurityTransparentAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.SecurityTreatAsSafeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.SuppressUnmanagedCodeSecurityAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.UnverifiableCodeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.VerificationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.XmlSyntaxException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.AccessControl.PrivilegeNotHeldException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Cryptography.CryptographicException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Cryptography.CryptographicUnexpectedOperationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.CodeAccessSecurityAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.EnvironmentPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.FileDialogPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.FileIOPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.GacIdentityPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.HostProtectionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.IsolatedStorageFilePermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.IsolatedStoragePermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.KeyContainerPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.PermissionSetAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.PrincipalPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.PublisherIdentityPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.ReflectionPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.RegistryPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.SecurityAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.SecurityPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.SiteIdentityPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.StrongNameIdentityPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.UIPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.UrlIdentityPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.ZoneIdentityPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Policy.PolicyException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Principal.IdentityNotMappedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Text.DecoderFallbackException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Text.EncoderFallbackException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.AbandonedMutexException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.LockRecursionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.SemaphoreFullException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.SynchronizationLockException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.Thread' does not implement interface 'System.Runtime.InteropServices._Thread' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.ThreadAbortException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.ThreadInterruptedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.ThreadStartException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.ThreadStateException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.WaitHandleCannotBeOpenedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.Tasks.TaskCanceledException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.Tasks.TaskSchedulerException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.UriFormatException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.CodeDom.Compiler.GeneratedCodeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.AmbientValueAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.AttributeProviderAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.BindableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.BrowsableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.CategoryAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ComplexBindingPropertiesAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataObjectAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataObjectFieldAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataObjectMethodAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DefaultBindingPropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DefaultEventAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DefaultPropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DefaultValueAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DesignerAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DesignerCategoryAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DesignerSerializationVisibilityAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DesignOnlyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DesignTimeVisibleAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DisplayNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.EditorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.EditorBrowsableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ExtenderProvidedPropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ImmutableObjectAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.InheritanceAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.InitializationEventAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.InstallerTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.InvalidAsynchronousStateException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.InvalidEnumArgumentException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.LicenseException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.LicenseProviderAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ListBindableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.LocalizableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.LookupBindingPropertiesAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.MergablePropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.NotifyParentPropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ParenthesizePropertyNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.PasswordPropertyTextAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.PropertyTabAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ProvidePropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ReadOnlyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.RecommendedAsConfigurableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.RefreshPropertiesAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.RunInstallerAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.SettingsBindableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ToolboxItemAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.ToolboxItemFilterAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.TypeConverterAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.TypeDescriptionProviderAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.WarningException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.Win32Exception' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.Design.CheckoutException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.Design.HelpKeywordAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.Design.Serialization.DefaultSerializationProviderAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.Design.Serialization.DesignerSerializerAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.Design.Serialization.RootDesignerSerializerAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.ApplicationScopedSettingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.ConfigurationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.DefaultSettingValueAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.NoSettingsVersionUpgradeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsDescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsGroupDescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsGroupNameAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsManageabilityAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsPropertyIsReadOnlyException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsPropertyNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsPropertyWrongTypeException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsProviderAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SettingsSerializeAsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SpecialSettingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.UserScopedSettingAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.MonitoringDescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.SwitchAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.SwitchLevelAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.InternalBufferOverflowException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.InvalidDataException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.CookieException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.HttpListenerException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.ProtocolViolationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.WebException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Mail.SmtpException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Mail.SmtpFailedRecipientException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Mail.SmtpFailedRecipientsException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.NetworkInformation.NetworkInformationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Sockets.SocketException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.WebSockets.WebSocketException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.DefaultParameterValueAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Authentication.AuthenticationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Authentication.InvalidCredentialException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.StorePermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Permissions.TypeDescriptorPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.BarrierPostPhaseException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.SemaphoreFullException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Timers.TimersDescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.AssociationAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.CompareAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.ConcurrencyCheckAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.CreditCardAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.CustomValidationAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.DataTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.DisplayAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.DisplayColumnAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.DisplayFormatAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.EditableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.EmailAddressAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.EnumDataTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.FileExtensionsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.FilterUIHintAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.KeyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.MaxLengthAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.MinLengthAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.PhoneAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.RangeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.RegularExpressionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.RequiredAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.ScaffoldColumnAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.StringLengthAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.TimestampAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.UIHintAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.UrlAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.ValidationAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.ValidationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.Schema.ColumnAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.Schema.ComplexTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.Schema.ForeignKeyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.Schema.InversePropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.Schema.NotMappedAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.ComponentModel.DataAnnotations.Schema.TableAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.InvalidTimeZoneException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.TimeZoneNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.DynamicAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.ExtensionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ComAwareEventInfo' does not implement interface 'System.Runtime.InteropServices._EventInfo' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.LockRecursionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.ConstraintException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.DataException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.DataSysDescriptionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.DBConcurrencyException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.DeletedRowInaccessibleException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.DuplicateNameException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.EvaluateException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.InRowChangingEventException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.InvalidConstraintException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.InvalidExpressionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.MissingPrimaryKeyException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.NoNullAllowedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.OperationAbortedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.ReadOnlyException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.RowNotInTableException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.StrongTypingException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SyntaxErrorException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.VersionNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.Common.DbException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.Common.DbProviderSpecificTypePropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.Common.DBDataPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.Odbc.OdbcException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlClient.SqlException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlTypes.SqlAlreadyFilledException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlTypes.SqlNotFilledException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlTypes.SqlNullValueException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlTypes.SqlTruncateException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlTypes.SqlTypeException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.CookieException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.WebException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Sockets.SocketException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.CollectionDataContractAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.ContractNamespaceAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.DataContractAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.DataMemberAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.EnumMemberAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.IgnoreDataMemberAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.InvalidDataContractException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.Serialization.KnownTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Transactions.TransactionAbortedException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Transactions.TransactionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Transactions.TransactionInDoubtException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Transactions.TransactionManagerCommunicationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Transactions.TransactionPromotionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.XmlException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Schema.XmlSchemaException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Schema.XmlSchemaInferenceException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Schema.XmlSchemaValidationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.SoapAttributeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.SoapElementAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.SoapEnumAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.SoapIgnoreAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.SoapIncludeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.SoapTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlAnyAttributeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlAnyElementAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlArrayAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlArrayItemAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlAttributeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlChoiceIdentifierAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlElementAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlEnumAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlIgnoreAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlIncludeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlNamespaceDeclarationsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlRootAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlSchemaProviderAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlSerializerAssemblyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlSerializerVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlTextAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.XPath.XPathException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Xsl.XsltCompileException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Xsl.XsltException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlAnyAttributeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlAnyElementAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlArrayAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlArrayItemAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlAttributeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlChoiceIdentifierAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlElementAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlEnumAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlIgnoreAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlIncludeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlNamespaceDeclarationsAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlRootAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlSchemaProviderAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlTextAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Xml.Serialization.XmlTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.ImportedFromTypeLibAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.TypeLibFuncAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.TypeLibImportClassAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.TypeLibTypeAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.TypeLibVarAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.InteropServices.TypeLibVersionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.PerformanceCounterPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.EventLogPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.DnsPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.SocketPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.WebPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Mail.SmtpPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.NetworkInformation.NetworkInformationPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.Odbc.OdbcPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.Printing.PrintingPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.PeerToPeer.PnrpPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.PeerToPeer.Collaboration.PeerCollaborationPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Transactions.DistributedTransactionPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Data.SqlClient.SqlClientPermissionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.CallbackValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.ConfigurationCollectionAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.ConfigurationErrorsException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.ConfigurationPropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.ConfigurationValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.IntegerValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.LongValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.PositiveTimeSpanValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.StringValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.SubclassTypeValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.TimeSpanValidatorAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Configuration.Provider.ProviderException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.BitmapSuffixInSameAssemblyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.BitmapSuffixInSatelliteAssemblyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.ToolboxBitmapAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.Printing.InvalidPrinterException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.FileFormatException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectExistsException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.ActiveDirectory.ActiveDirectoryOperationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.ActiveDirectory.ActiveDirectoryServerDownException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.ActiveDirectory.ForestTrustCollisionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.ActiveDirectory.SyncFromAllServersOperationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.DirectoryObjectClassAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.DirectoryPropertyAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.DirectoryRdnPrefixAttribute' does not implement interface 'System.Runtime.InteropServices._Attribute' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.MultipleMatchesException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.NoMatchingPrincipalException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.PasswordException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.PrincipalException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.PrincipalExistsException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.PrincipalOperationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.AccountManagement.PrincipalServerDownException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.Protocols.BerConversionException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.Protocols.DirectoryException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.Protocols.DirectoryOperationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.Protocols.LdapException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.DirectoryServices.Protocols.TlsOperationException' does not implement interface 'System.Runtime.InteropServices._Exception' in the implementation but it does in the contract.
-
-
-
-// Types we currently don't plan to port:
-TypesMustExist : Type 'System._AppDomain' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ActivationContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.AppDomainInitializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.AppDomainManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.AppDomainManagerInitializationOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.AppDomainSetup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.CrossAppDomainDelegate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IAppDomainSetup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Deployment.Internal.InternalActivationContextHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Deployment.Internal.InternalApplicationIdentityHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Contracts.Internal.ContractHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.DesignerServices.WindowsRuntimeDesignerContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Hosting.ActivationArguments' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Hosting.ApplicationActivator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._Activator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._Assembly' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._AssemblyBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._AssemblyName' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._Attribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._ConstructorBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._ConstructorInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._CustomAttributeBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._EnumBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._EventBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._EventInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._Exception' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._FieldBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._FieldInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._ILGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._LocalBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._MemberInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._MethodBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._MethodBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._MethodInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._MethodRental' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._Module' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._ModuleBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._ParameterBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._ParameterInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._PropertyBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._PropertyInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._SignatureHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._Thread' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._Type' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices._TypeBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.AssemblyRegistrationFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.BIND_OPTS' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.BINDPTR' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.CALLCONV' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.CONNECTDATA' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.DESCKIND' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.DISPPARAMS' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ELEMDESC' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.EXCEPINFO' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ExporterEventKind' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ExtensibleClassFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.FILETIME' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.FUNCDESC' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.FUNCFLAGS' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.FUNCKIND' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.IDispatchImplAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.IDispatchImplType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.IDLDESC' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.IDLFLAG' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.IMPLTYPEFLAGS' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ImporterEventKind' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.INVOKEKIND' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.IRegistrationServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ITypeLibConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ITypeLibExporterNameProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ITypeLibExporterNotifySink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ITypeLibImporterNotifySink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.LIBFLAGS' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ObjectCreationDelegate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.PARAMDESC' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.PARAMFLAG' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.RegistrationClassContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.RegistrationConnectionType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.RegistrationServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.SetWin32ContextInIDispatchAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.STATSTG' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.SYSKIND' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TYPEATTR' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TYPEDESC' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TYPEFLAGS' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TYPEKIND' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TYPELIBATTR' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibExporterFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibImporterFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIBindCtx' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIConnectionPoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIConnectionPointContainer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIEnumConnectionPoints' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIEnumConnections' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIEnumMoniker' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIEnumString' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIEnumVARIANT' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIMoniker' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIPersistFile' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIRunningObjectTable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMIStream' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMITypeComp' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMITypeInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.UCOMITypeLib' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.VARDESC' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.VARFLAGS' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.Expando.IExpando' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.WindowsRuntime.DesignerNamespaceResolveEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.WindowsRuntime.NamespaceResolveEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.ActivatedClientTypeEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.ActivatedServiceTypeEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.CustomErrorsModes' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.IChannelInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.IEnvoyInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.InternalRemotingServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.IObjectHandle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.IRemotingTypeInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.ObjectHandle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.ObjRef' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.RemotingConfiguration' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.RemotingException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.RemotingServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.RemotingTimeoutException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.ServerException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.SoapServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.TypeEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.WellKnownClientTypeEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.WellKnownObjectMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.WellKnownServiceTypeEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Activation.ActivatorLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Activation.IActivator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Activation.IConstructionCallMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Activation.IConstructionReturnMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Activation.UrlAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.BaseChannelObjectWithProperties' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.BaseChannelSinkWithProperties' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.BaseChannelWithProperties' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.ChannelDataStore' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.ChannelServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.ClientChannelSinkStack' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IChannel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IChannelDataStore' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IChannelReceiver' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IChannelReceiverHook' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IChannelSender' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IChannelSinkBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IClientChannelSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IClientChannelSinkProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IClientChannelSinkStack' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IClientFormatterSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IClientFormatterSinkProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IClientResponseChannelSinkStack' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.ISecurableChannel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IServerChannelSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IServerChannelSinkProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IServerChannelSinkStack' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IServerFormatterSinkProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.IServerResponseChannelSinkStack' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.ITransportHeaders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.ServerChannelSinkStack' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.ServerProcessing' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.SinkProviderData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Channels.TransportHeaders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.Context' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.ContextAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.ContextProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.CrossContextDelegate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContextAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContextProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContextPropertyActivator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContributeClientContextSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContributeDynamicSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContributeEnvoySink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContributeObjectSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IContributeServerContextSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IDynamicMessageSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.IDynamicProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Contexts.SynchronizationAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Lifetime.ClientSponsor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Lifetime.ILease' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Lifetime.ISponsor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Lifetime.LeaseState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Lifetime.LifetimeServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.AsyncResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.CallContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.ConstructionCall' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.ConstructionResponse' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.Header' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.HeaderHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.ILogicalThreadAffinative' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.IMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.IMessageCtrl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.IMessageSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.IMethodCallMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.IMethodMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.IMethodReturnMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.InternalMessageWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.LogicalCallContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.MessageSurrogateFilter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.MethodCall' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.MethodCallMessageWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.MethodResponse' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.MethodReturnMessageWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.OneWayAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.RemotingSurrogateSelector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Messaging.ReturnMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.SoapAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.SoapFieldAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.SoapMethodAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.SoapOption' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.SoapParameterAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.SoapTypeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.XmlFieldOrderOption' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.ISoapXsd' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapAnyUri' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapBase64Binary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDateTime' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDay' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapDuration' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntities' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapEntity' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapHexBinary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapId' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdref' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapIdrefs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapInteger' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapLanguage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonth' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapMonthDay' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapName' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNcName' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNegativeInteger' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtoken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNmtokens' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonNegativeInteger' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNonPositiveInteger' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNormalizedString' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNotation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapPositiveInteger' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapQName' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapTime' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYear' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Metadata.W3cXsd2001.SoapYearMonth' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Proxies.ProxyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Proxies.RealProxy' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Services.EnterpriseServicesHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Services.ITrackingHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Remoting.Services.TrackingServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.ReadOnlyPermissionSet' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'Microsoft.Win32.IntranetZoneCredentialPolicy' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Media.SoundPlayer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Media.SystemSound' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Media.SystemSounds' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Web:
-TypesMustExist : Type 'System.Web.ApplicationShutdownReason' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.BeginEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.DefaultHttpHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.EndEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.EventHandlerTaskAsyncHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HtmlString' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpApplication' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpApplicationState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpApplicationStateBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpApplicationStateWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpBrowserCapabilities' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpBrowserCapabilitiesBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpBrowserCapabilitiesWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCacheability' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCachePolicy' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCachePolicyBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCachePolicyWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCacheRevalidation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCacheValidateHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCacheVaryByContentEncodings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCacheVaryByHeaders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCacheVaryByParams' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpClientCertificate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCompileException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpContextBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpContextWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCookie' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCookieCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpCookieMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpFileCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpFileCollectionBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpFileCollectionWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpModuleCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpParseException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpPostedFile' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpPostedFileBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpPostedFileWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpRequest' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpRequestBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpRequestValidationException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpRequestWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpResponse' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpResponseBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpResponseSubstitutionCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpResponseWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpRuntime' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpServerUtility' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpServerUtilityBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpServerUtilityWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpSessionStateBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpSessionStateWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpStaticObjectsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpStaticObjectsCollectionBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpStaticObjectsCollectionWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpTaskAsyncHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpUnhandledException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpValidationStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpWorkerRequest' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.HttpWriter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.IHtmlString' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.IHttpAsyncHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.IHttpHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.IHttpHandlerFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.IHttpModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.IisTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.IPartitionResolver' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ISubscriptionToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ITlsTokenBindingInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.MimeMapping' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ParserError' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ParserErrorCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.PreApplicationStartMethodAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ProcessInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ProcessModelInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ProcessShutdownReason' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ProcessStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ReadEntityBodyMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.RequestNotification' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.RequestNotificationStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SiteMap' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SiteMapNode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SiteMapNodeCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SiteMapProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SiteMapProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SiteMapResolveEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SiteMapResolveEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.StaticSiteMapProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.TaskEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.TraceContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.TraceContextEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.TraceContextEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.TraceContextRecord' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.TraceMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UnvalidatedRequestValues' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UnvalidatedRequestValuesBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UnvalidatedRequestValuesWrapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.VirtualPathUtility' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.WebPageTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.XmlSiteMapProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.AggregateCacheDependency' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.Cache' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.CacheDependency' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.CacheItemPriority' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.CacheItemRemovedCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.CacheItemRemovedReason' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.CacheItemUpdateCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.CacheItemUpdateReason' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.DatabaseNotEnabledForNotificationException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.FileResponseElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.HeaderElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.IOutputCacheEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.MemoryResponseElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.OutputCache' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.OutputCacheProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.OutputCacheProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.ResponseElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.SqlCacheDependency' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.SqlCacheDependencyAdmin' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.SubstitutionResponseElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Caching.TableNotEnabledForNotificationException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.AppSettingsExpressionBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.AssemblyBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildDependencySet' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildManagerHostUnloadEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildManagerHostUnloadEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildProviderAppliesTo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildProviderAppliesToAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.BuildProviderResultFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ClientBuildManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ClientBuildManagerCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ClientBuildManagerParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.CompilerType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ConnectionStringsExpressionBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ControlBuilderInterceptor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.DesignTimeResourceProviderFactoryAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ExpressionBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ExpressionBuilderContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ExpressionEditorAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ExpressionPrefixAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.FolderLevelBuildProviderAppliesTo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.FolderLevelBuildProviderAppliesToAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.IAssemblyPostProcessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.IImplicitResourceProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ImplicitResourceKey' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.IResourceProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.LinePragmaCodeInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.PrecompilationFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ResourceExpressionBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ResourceExpressionFields' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.ResourceProviderFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.RouteUrlExpressionBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Compilation.RouteValueExpressionBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AdapterDictionary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AnonymousIdentificationSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AssemblyCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AssemblyInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AsyncPreloadModeFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AuthenticationMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AuthenticationSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AuthorizationRule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AuthorizationRuleAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AuthorizationRuleCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.AuthorizationSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.BrowserCapabilitiesCodeGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.BrowserCapabilitiesFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.BrowserCapabilitiesFactoryBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.BufferModesCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.BufferModeSettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.BuildProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.BuildProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CacheSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ClientTarget' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ClientTargetCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ClientTargetSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CodeSubDirectoriesCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CodeSubDirectory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CompilationSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.Compiler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CompilerCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CustomError' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CustomErrorCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CustomErrorsMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CustomErrorsRedirectMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.CustomErrorsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.DeploymentSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.EventMappingSettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.EventMappingSettingsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ExpressionBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ExpressionBuilderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FcnMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FolderLevelBuildProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FolderLevelBuildProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FormsAuthenticationConfiguration' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FormsAuthenticationCredentials' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FormsAuthenticationUser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FormsAuthenticationUserCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FormsAuthPasswordFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FormsProtectionEnum' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FullTrustAssembliesSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FullTrustAssembly' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.FullTrustAssemblyCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.GlobalizationSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HealthMonitoringSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HostingEnvironmentSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpCapabilitiesBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpCapabilitiesDefaultProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpCapabilitiesProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpCapabilitiesSectionHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpConfigurationContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpCookiesSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpHandlerAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpHandlerActionCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpHandlersSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpModuleAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpModuleActionCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpModulesSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.HttpRuntimeSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.IConfigMapPath' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.IConfigMapPathFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.IdentitySection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.IgnoreDeviceFilterElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.IgnoreDeviceFilterElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.IRemoteWebConfigurationHostServer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.LowerCaseStringConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.MachineKeyCompatibilityMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.MachineKeySection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.MachineKeyValidation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.MachineKeyValidationConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.MembershipSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.NamespaceCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.NamespaceInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.OutputCacheProfile' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.OutputCacheProfileCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.OutputCacheSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.OutputCacheSettingsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.PagesEnableSessionState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.PagesSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.PartialTrustVisibleAssembliesSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.PartialTrustVisibleAssembly' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.PartialTrustVisibleAssemblyCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.PassportAuthentication' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProcessModelComAuthenticationLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProcessModelComImpersonationLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProcessModelLogLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProcessModelSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfileGroupSettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfileGroupSettingsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfileGuidedOptimizationsFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfilePropertySettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfilePropertySettingsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfileSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfileSettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProfileSettingsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProtocolCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProtocolElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProtocolsConfigurationHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProtocolsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.ProvidersHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.RegexWorker' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.RemoteWebConfigurationHostServer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.RoleManagerSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.RootProfilePropertySettingsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.RuleSettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.RuleSettingsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SecurityPolicySection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SerializationMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SessionPageStateSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SessionStateSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SiteMapSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SqlCacheDependencyDatabase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SqlCacheDependencyDatabaseCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SqlCacheDependencySection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SystemWebCachingSectionGroup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.SystemWebSectionGroup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TagMapCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TagMapInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TagPrefixCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TagPrefixInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TicketCompatibilityMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TraceDisplayMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TraceSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TransformerInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TransformerInfoCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TrustLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TrustLevelCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.TrustSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.UrlMapping' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.UrlMappingCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.UrlMappingsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.UserMapPath' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.VirtualDirectoryMapping' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.VirtualDirectoryMappingCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebApplicationLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebConfigurationFileMap' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebConfigurationManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebControlsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebPartsPersonalization' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebPartsPersonalizationAuthorization' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.WebPartsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.XhtmlConformanceMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.XhtmlConformanceSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Configuration.Internal.IInternalConfigWebHost' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Handlers.AssemblyResourceLoader' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Handlers.TraceHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.AppDomainFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.AppDomainInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.AppDomainInfoEnum' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.AppDomainProtocolHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ApplicationHost' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ApplicationInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ApplicationManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.AppManagerAppDomainFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.HostingEnvironment' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.HostSecurityPolicyResolver' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.HostSecurityPolicyResults' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IAdphManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IAppDomainFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IAppDomainInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IAppDomainInfoEnum' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IApplicationHost' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IApplicationPreloadManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IApplicationPreloadUtil' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IAppManagerAppDomainFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IISAPIRuntime' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IListenerChannelCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IPphManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IProcessHost' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IProcessHostFactoryHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IProcessHostIdleAndHealthCheck' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IProcessHostPreloadClient' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IProcessHostSupportFunctions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IProcessPingCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IRegisteredObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ISAPIRuntime' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.IStopListeningRegisteredObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ISuspendibleRegisteredObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ProcessHost' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ProcessHostFactoryHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.ProcessProtocolHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.SimpleWorkerRequest' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.VirtualDirectory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.VirtualFile' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.VirtualFileBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Hosting.VirtualPathProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Instrumentation.PageExecutionContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Instrumentation.PageExecutionListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Instrumentation.PageInstrumentationService' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Mail.MailAttachment' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Mail.MailEncoding' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Mail.MailFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Mail.MailMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Mail.MailPriority' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Mail.SmtpMail' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.BufferedWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.EventLogWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.EventNotificationType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.IisTraceWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.IRegiisUtility' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.IWebEventCustomEvaluator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.MailEventNotificationInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.MailWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.RegiisUtility' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.RuleFiringRecord' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.SessionStateType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.SimpleMailWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.SqlExecutionException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.SqlFeatures' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.SqlServices' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.SqlWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.TemplatedMailWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.TraceWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebApplicationInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebApplicationLifetimeEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebAuditEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebAuthenticationFailureAuditEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebAuthenticationSuccessAuditEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebBaseErrorEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebBaseEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebBaseEventCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebErrorEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebEventBufferFlushInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebEventCodes' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebEventFormatter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebEventManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebFailureAuditEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebHeartbeatEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebManagementEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebProcessInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebProcessStatistics' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebRequestErrorEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebRequestEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebRequestInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebSuccessAuditEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebThreadInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WebViewStateFailureAuditEvent' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Management.WmiWebEventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ArrayModelBinder<TElement>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ArrayModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.AssociatedMetadataProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.AssociatedValidatorProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.BinaryDataModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.BindingBehavior' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.BindingBehaviorAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.BindNeverAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.BindRequiredAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.CollectionModelBinder<TElement>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.CollectionModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ComplexModel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ComplexModelBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ComplexModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ComplexModelResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ControlAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ControlValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.CookieAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.CookieValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DataAnnotationsModelMetadata' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DataAnnotationsModelMetadataProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DataAnnotationsModelValidationFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DataAnnotationsModelValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DataAnnotationsModelValidator<TAttribute>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DataAnnotationsModelValidatorProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DataAnnotationsValidatableObjectAdapterFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DefaultModelBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DictionaryModelBinder<TKey, TValue>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DictionaryModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.DictionaryValueProvider<TValue>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.EmptyModelMetadataProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ExtensibleModelBinderAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.FormAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.FormValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.GenericModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.IMetadataAware' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.IModelBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.IModelNameProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.IUnvalidatedValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.IUnvalidatedValueProviderSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.IValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.IValueProviderSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.KeyValuePairModelBinder<TKey, TValue>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.KeyValuePairModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinderDictionary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinderErrorMessageProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinderErrorMessageProviders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinderProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinderProviderOptionsAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinderProviders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBinders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBindingContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelBindingExecutionContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelError' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelErrorCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelMetadata' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelMetadataProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelMetadataProviders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelStateDictionary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidatedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidatingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidationNode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidationResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidatorProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidatorProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ModelValidatorProviders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.MutableObjectModelBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.MutableObjectModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.NameValueCollectionValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ProfileAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ProfileValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.QueryStringAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.QueryStringValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.RangeAttributeAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.RegularExpressionAttributeAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.RequiredAttributeAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.RouteDataAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.RouteDataValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.SessionAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.SimpleModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.SimpleValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.StringLengthAttributeAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.TypeConverterModelBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.TypeConverterModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.TypeMatchModelBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.TypeMatchModelBinderProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.UserProfileAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.UserProfileValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ValidatableObjectAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ValueProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ValueProviderResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ValueProviderSourceAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ViewStateAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.ModelBinding.ViewStateValueProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.CustomProviderDataAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.DefaultProfile' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileAuthenticationOption' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileAutoSaveEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileAutoSaveEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileGroupBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileInfoCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileMigrateEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileMigrateEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileProviderAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.ProfileProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.SettingsAllowAnonymousAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Profile.SqlProfileProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.HttpMethodConstraint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.IRouteConstraint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.IRouteHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.PageRouteHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.RequestContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.Route' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.RouteBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.RouteCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.RouteData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.RouteDirection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.RouteTable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.RouteValueDictionary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.StopRoutingHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.UrlRoutingHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.UrlRoutingModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Routing.VirtualPathData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.ActiveDirectoryConnectionProtection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.ActiveDirectoryMembershipProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.ActiveDirectoryMembershipUser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AnonymousIdentificationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AnonymousIdentificationEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AnonymousIdentificationModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AuthorizationStoreRoleProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.CookieProtection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.DefaultAuthenticationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.DefaultAuthenticationEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.DefaultAuthenticationModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.FileAuthorizationModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.FormsAuthentication' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.FormsAuthenticationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.FormsAuthenticationEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.FormsAuthenticationModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.FormsAuthenticationTicket' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.FormsIdentity' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.MachineKey' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.MachineKeyProtection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.Membership' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.MembershipPasswordAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.PassportAuthenticationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.PassportAuthenticationEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.PassportAuthenticationModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.PassportIdentity' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.PassportPrincipal' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.RoleManagerEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.RoleManagerEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.RoleManagerModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.RolePrincipal' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.RoleProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.Roles' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.SqlMembershipProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.SqlRoleProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.UrlAuthorizationModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.WindowsAuthenticationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.WindowsAuthenticationEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.WindowsAuthenticationModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.WindowsTokenRoleProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AntiXss.AntiXssEncoder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AntiXss.LowerCodeCharts' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AntiXss.LowerMidCodeCharts' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AntiXss.MidCodeCharts' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AntiXss.UpperCodeCharts' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Security.AntiXss.UpperMidCodeCharts' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.HttpSessionState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.HttpSessionStateContainer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.IHttpSessionState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.IPartialSessionState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.IReadOnlySessionState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.IRequiresSessionState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.ISessionIDManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.ISessionStateItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.IStateRuntime' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionIDManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateActions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateBehavior' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateItemExpireCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateModule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateStoreData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateStoreProviderBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.SessionStateUtility' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.SessionState.StateRuntime' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.AttributeCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BaseParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BasePartialCachingControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BaseTemplateParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BindableTemplateBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BoundPropertyEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BuilderPropertyEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BuildMethod' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.BuildTemplateMethod' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ChtmlTextWriter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ClientIDMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ClientScriptManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CodeBlockType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CodeConstructType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CodeStatementBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CompilationMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CompiledBindableTemplateBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CompiledTemplateBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ComplexPropertyEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ConflictOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ConstructorNeedsTagAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.Control' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ControlBuilderAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ControlCachePolicy' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ControlCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ControlSkin' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ControlSkinDelegate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ControlValuePropertyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CssClassPropertyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.CssStyleCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataBinding' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataBindingCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataBindingHandlerAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataBoundLiteralControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataKeyPropertyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceCacheDurationConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceCacheExpiry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceCapabilities' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceOperation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceSelectArguments' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceViewOperationCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DataSourceViewSelectCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DesignerDataBoundLiteralControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DesignTimeParseData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.DesignTimeTemplateParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.EmptyControlCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.EventEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ExpressionBinding' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ExpressionBindingCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ExtractTemplateValuesMethod' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.FileLevelControlBuilderAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.FileLevelMasterPageControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.FileLevelPageControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.FileLevelUserControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.FilterableAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HiddenFieldPageStatePersister' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HierarchicalDataSourceControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HierarchicalDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.Html32TextWriter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlTextWriter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlTextWriterAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlTextWriterStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlTextWriterTag' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IAttributeAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IAutoFieldGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IBindableControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IBindableTemplate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ICallbackEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ICheckBoxControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ICodeBlockTypeAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IControlBuilderAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IControlDesignerAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IDataBindingsAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IDataItemContainer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IDataKeysControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IDataSourceViewSchemaAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IDReferencePropertyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IEditableTextControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IExpressionsAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IFilterResolutionService' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IHierarchicalDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IHierarchicalEnumerable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IHierarchyData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ImageClickEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ImageClickEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.INamingContainer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.INavigateUIData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IndexedString' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IParserAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IPostBackDataHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IPostBackEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IResourceUrlGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IStateFormatter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IStateManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IStyleSheet' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ITemplate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ITextControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IThemeResolutionService' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IUrlResolutionService' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IUserControlDesignerAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IUserControlTypeResolutionService' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.IValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ListSourceHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.LiteralControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.LosFormatter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.MasterPage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.MasterPageControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.NonVisualControlAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ObjectConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ObjectPersistData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ObjectStateFormatter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ObjectTagBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.OutputCacheLocation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.OutputCacheParameters' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.Page' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PageAsyncTask' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PageHandlerFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PageParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PageParserFilter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PageStatePersister' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PageTheme' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.Pair' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ParseChildrenAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ParseRecorder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PartialCachingAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PartialCachingControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PersistChildrenAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PersistenceMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PersistenceModeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PostBackOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PropertyConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.PropertyEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.RenderMethod' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.RenderTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.RootBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.SessionPageStatePersister' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.SimplePropertyEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.SimpleWebHandlerParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.SkinBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.StateBag' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.StateItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.StateManagedCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.StaticPartialCachingControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.SupportsEventValidationAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TagPrefixAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplateBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplateContainerAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplateControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplateControlParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplateInstance' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplateInstanceAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplateParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.TemplatePropertyEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ThemeableAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ThemeProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ToolboxDataAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.Triplet' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.UnobtrusiveValidationMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.UrlPropertyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.UserControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.UserControlControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ValidateRequestMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ValidationPropertyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ValidationSettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ValidatorCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.VerificationAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.VerificationConditionalOperator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.VerificationReportLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.VerificationRule' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ViewStateEncryptionMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ViewStateException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ViewStateMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.ViewStateModeByIdAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.VirtualReferenceType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebResourceAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebServiceParser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.XhtmlMobileDocType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.XhtmlTextWriter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.XPathBinder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.Adapters.ControlAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.Adapters.PageAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlAnchor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlArea' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlAudio' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlButton' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlContainerControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlEmbed' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlEmptyTagControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlForm' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlGenericControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlHead' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlHeadBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlIframe' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlImage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputButton' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputCheckBox' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputFile' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputGenericControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputHidden' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputImage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputPassword' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputRadioButton' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputReset' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputSubmit' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlInputText' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlLink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlMeta' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlSelect' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlSelectBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTableCell' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTableCellCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTableRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTableRowCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTextArea' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTitle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlTrack' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.HtmlControls.HtmlVideo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AccessDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AccessDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AdCreatedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AdCreatedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AdRotator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AssociatedControlConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AuthenticateEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AuthenticateEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AutoCompleteType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AutoFieldsGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AutoGeneratedField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.AutoGeneratedFieldProperties' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BaseCompareValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BaseDataBoundControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BaseDataList' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BaseValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BorderStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BoundColumn' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BoundField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BulletedList' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BulletedListDisplayMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BulletedListEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BulletedListEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.BulletStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Button' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ButtonColumn' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ButtonColumnType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ButtonField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ButtonFieldBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ButtonType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Calendar' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CalendarDay' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CalendarSelectionMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CallingDataMethodsEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CallingDataMethodsEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ChangePassword' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CheckBox' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CheckBoxField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CheckBoxList' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CircleHotSpot' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CommandField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CompareValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CompleteWizardStep' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CompositeControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CompositeDataBoundControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Content' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ContentDirection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ContentPlaceHolder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ControlIDConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ControlParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ControlPropertyNameConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CookieParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CreateUserErrorEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CreateUserErrorEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CreateUserWizard' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CreateUserWizardStep' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CreatingModelDataSourceEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CreatingModelDataSourceEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.CustomValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataBoundControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataBoundControlMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlCellType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlCommands' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlFieldCell' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlFieldCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlFieldHeaderCell' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlRowState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataControlRowType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGrid' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridColumn' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridColumnCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridItemEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridItemEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridPageChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridPageChangedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridPagerStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridSortCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataGridSortCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataKey' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataKeyArray' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataKeyCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataList' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataListCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataListCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataListItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataListItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataListItemEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataListItemEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DataSourceSelectResultProcessingOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DayNameFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DayRenderEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DayRenderEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewDeletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewDeletedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewDeleteEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewDeleteEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewInsertedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewInsertedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewInsertEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewInsertEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewModeEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewModeEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewPageEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewPageEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewPagerRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewRowCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewRowsGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewUpdatedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewUpdatedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewUpdateEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DetailsViewUpdateEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.DropDownList' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.EditCommandColumn' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.EmbeddedMailObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.EmbeddedMailObjectsCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FileUpload' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FirstDayOfWeek' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FontInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FontNamesConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FontSize' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FontUnit' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FontUnitConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewDeletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewDeletedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewDeleteEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewDeleteEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewInsertedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewInsertedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewInsertEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewInsertEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewModeEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewModeEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewPageEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewPageEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewPagerRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewUpdatedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewUpdatedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewUpdateEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.FormViewUpdateEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridLines' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewCancelEditEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewCancelEditEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewColumnsGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewDeletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewDeletedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewDeleteEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewDeleteEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewEditEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewEditEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewPageEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewPageEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewRowCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewRowEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewRowEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewSelectEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewSelectEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewSortEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewSortEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewUpdatedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewUpdatedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewUpdateEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.GridViewUpdateEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HiddenField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HierarchicalDataBoundControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HorizontalAlign' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HotSpot' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HotSpotCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HotSpotMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HyperLink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HyperLinkColumn' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HyperLinkControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.HyperLinkField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IButtonControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ICallbackContainer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ICompositeControlDesignerAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IDataBoundControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IDataBoundItemControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IDataBoundListControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IFieldControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Image' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ImageAlign' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ImageButton' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ImageField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ImageMap' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ImageMapEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ImageMapEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IPersistedSelector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IPostBackContainer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.IRepeatInfoUser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Label' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LabelControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LinkButton' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LinkButtonControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ListBox' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ListControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ListItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ListItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ListItemControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ListItemType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ListSelectionMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Literal' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LiteralControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LiteralMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Localize' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Login' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LoginCancelEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LoginCancelEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LoginFailureAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LoginName' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LoginStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LoginTextLayout' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LoginView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.LogoutAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MailDefinition' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MailMessageEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MailMessageEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Menu' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuItemBinding' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuItemBindingCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuItemStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuItemStyleCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuItemTemplateContainer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MenuRenderingMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ModelDataMethodResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ModelDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ModelDataSourceMethod' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ModelDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ModelErrorMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ModelMethodContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MonthChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MonthChangedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MultiView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.MultiViewControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.NextPrevFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceDisposingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceDisposingEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceFilteringEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceFilteringEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceMethodEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceMethodEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceObjectEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceSelectingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceSelectingEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceStatusEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceStatusEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ObjectDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Orientation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PagedDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PagerButtons' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PagerMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PagerPosition' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PagerSettings' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Panel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PanelStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Parameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ParameterCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ParsingCulture' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PasswordRecovery' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PathDirection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PlaceHolder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PlaceHolderControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.PolygonHotSpot' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ProfileParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.QueryExtensions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.QueryStringParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RadioButton' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RadioButtonList' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RangeValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RectangleHotSpot' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RegularExpressionValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeatDirection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Repeater' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeaterCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeaterCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeaterItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeaterItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeaterItemEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeaterItemEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeatInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RepeatLayout' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RequiredFieldValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RoleGroup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RoleGroupCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.RouteParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ScrollBars' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SelectedDatesCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SelectResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SendMailErrorEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SendMailErrorEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ServerValidateEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ServerValidateEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SessionParameter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapHierarchicalDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapNodeItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapNodeItemEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapNodeItemEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapNodeItemType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SiteMapPath' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SortDirection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceCommandEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceCommandEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceCommandType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceFilteringEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceFilteringEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceSelectingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceSelectingEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceStatusEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceStatusEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SqlDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.StringArrayConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Style' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.StyleCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SubMenuStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.SubMenuStyleCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Substitution' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Table' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableCaptionAlign' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableCell' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableCellCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableCellControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableFooterRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableHeaderCell' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableHeaderRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableHeaderScope' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableItemStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableRowCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableRowSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableSectionStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TableStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TargetConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TemplateColumn' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TemplatedWizardStep' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TemplateField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TextAlign' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TextBox' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TextBoxControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TextBoxMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TitleFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeBinding' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeBindingCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeSelectAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeStyleCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeNodeTypes' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.TreeViewImageSet' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Unit' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.UnitConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.UnitType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ValidatedControlConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ValidationCompareOperator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ValidationDataType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ValidationSummary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ValidationSummaryDisplayMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ValidatorDisplay' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.VerticalAlign' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.View' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.ViewCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebColorConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Wizard' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WizardNavigationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WizardNavigationEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WizardStep' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WizardStepBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WizardStepCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WizardStepControlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WizardStepType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Xml' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.XmlBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.XmlDataSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.XmlDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.XmlHierarchicalDataSourceView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Adapters.DataBoundControlAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Adapters.HideDisabledControlAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Adapters.HierarchicalDataBoundControlAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Adapters.MenuAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.Adapters.WebControlAdapter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.AppearanceEditorPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.BehaviorEditorPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.CatalogPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.CatalogPartChrome' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.CatalogPartCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.CatalogZone' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.CatalogZoneBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ConnectionConsumerAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ConnectionInterfaceCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ConnectionPoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ConnectionProviderAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ConnectionsZone' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ConsumerConnectionPoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ConsumerConnectionPointCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.DeclarativeCatalogPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.EditorPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.EditorPartChrome' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.EditorPartCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.EditorZone' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.EditorZoneBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ErrorWebPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.FieldCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.GenericWebPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ImportCatalogPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IPersonalizable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ITrackingPersonalizable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ITransformerConfigurationControl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IVersioningPersonalizable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IWebActionable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IWebEditable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IWebPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IWebPartField' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IWebPartParameters' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IWebPartRow' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.IWebPartTable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.LayoutEditorPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PageCatalogPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ParametersCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.Part' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PartChromeState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PartChromeType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizableAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationAdministration' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationDictionary' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationProviderCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationScope' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationStateInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationStateInfoCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PersonalizationStateQuery' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.PropertyGridEditorPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ProviderConnectionPoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ProviderConnectionPointCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ProxyWebPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ProxyWebPartConnectionCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ProxyWebPartManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.RowCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.RowToFieldTransformer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.RowToParametersTransformer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.SharedPersonalizationStateInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.SqlPersonalizationProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.TableCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.TitleStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.ToolZone' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.TransformerTypeCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.UnauthorizedWebPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.UserPersonalizationStateInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebBrowsableAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebDescriptionAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebDisplayNameAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPart' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartAddingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartAddingEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartAuthorizationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartAuthorizationEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartCancelEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartCancelEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartChrome' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartConnection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartConnectionCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartConnectionsCancelEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartConnectionsCancelEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartConnectionsEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartConnectionsEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDescription' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDescriptionCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDisplayMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDisplayModeCancelEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDisplayModeCancelEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDisplayModeCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDisplayModeEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartDisplayModeEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartExportMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartHelpMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartManagerInternals' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartMenuStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartMovingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartMovingEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartPersonalization' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartTracker' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartTransformer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartTransformerAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartTransformerCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartUserCapability' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartVerb' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartVerbCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartVerbRenderMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartVerbsEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartVerbsEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartZone' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartZoneBase' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebPartZoneCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.UI.WebControls.WebParts.WebZone' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.HttpEncoder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.IWebObjectFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.IWebPropertyAccessor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.RequestValidationSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.RequestValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.TransactedCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.Transactions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.WorkItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.Util.WorkItemCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.WebSockets.AspNetWebSocket' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.WebSockets.AspNetWebSocketContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Web.WebSockets.AspNetWebSocketOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.ValueSerializerAttribute' does not exist in the implementation but it does exist in the contract.
-
-// Members can't be added because types are on NS20 and the missing members required types that are not on NS20 and we are ignoring those for netcore20:
-MembersMustExist : Member 'System.Activator.CreateComInstanceFrom(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateComInstanceFrom(System.String, System.String, System.Byte[], System.Configuration.Assemblies.AssemblyHashAlgorithm)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.ActivationContext)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.ActivationContext, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.AppDomain, System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.AppDomain, System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.AppDomain, System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstance(System.String, System.String, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstanceFrom(System.AppDomain, System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstanceFrom(System.AppDomain, System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstanceFrom(System.AppDomain, System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstanceFrom(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstanceFrom(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstanceFrom(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.CreateInstanceFrom(System.String, System.String, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.GetObject(System.Type, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Activator.GetObject(System.Type, System.String, System.Object)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ActivationContext.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ApplicationIdentity.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ApplicationTrust.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateComInstanceFrom(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateComInstanceFrom(System.String, System.String, System.Byte[], System.Configuration.Assemblies.AssemblyHashAlgorithm)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateDomain(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateDomain(System.String, System.Security.Policy.Evidence, System.AppDomainSetup)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateDomain(System.String, System.Security.Policy.Evidence, System.AppDomainSetup, System.Security.PermissionSet, System.Security.Policy.StrongName[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateDomain(System.String, System.Security.Policy.Evidence, System.String, System.String, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateDomain(System.String, System.Security.Policy.Evidence, System.String, System.String, System.Boolean, System.AppDomainInitializer, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstance(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstance(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstance(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstance(System.String, System.String, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceAndUnwrap(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceAndUnwrap(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceAndUnwrap(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceAndUnwrap(System.String, System.String, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFrom(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFrom(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFrom(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFrom(System.String, System.String, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFromAndUnwrap(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFromAndUnwrap(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFromAndUnwrap(System.String, System.String, System.Boolean, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.CreateInstanceFromAndUnwrap(System.String, System.String, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder>, System.Security.SecurityContextSource)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.Security.PermissionSet, System.Security.PermissionSet, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.Security.Policy.Evidence, System.Security.PermissionSet, System.Security.PermissionSet, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.String, System.Boolean, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.String, System.Security.PermissionSet, System.Security.PermissionSet, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.String, System.Security.Policy.Evidence, System.Security.PermissionSet, System.Security.PermissionSet, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.String, System.Security.Policy.Evidence, System.Security.PermissionSet, System.Security.PermissionSet, System.Security.PermissionSet, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DefineDynamicAssembly(System.Reflection.AssemblyName, System.Reflection.Emit.AssemblyBuilderAccess, System.String, System.Security.Policy.Evidence, System.Security.PermissionSet, System.Security.PermissionSet, System.Security.PermissionSet, System.Boolean, System.Collections.Generic.IEnumerable<System.Reflection.Emit.CustomAttributeBuilder>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DoCallBack(System.CrossAppDomainDelegate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.DomainManager.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.Evidence.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ExecuteAssembly(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ExecuteAssembly(System.String, System.Security.Policy.Evidence, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ExecuteAssembly(System.String, System.Security.Policy.Evidence, System.String[], System.Byte[], System.Configuration.Assemblies.AssemblyHashAlgorithm)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ExecuteAssemblyByName(System.Reflection.AssemblyName, System.Security.Policy.Evidence, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ExecuteAssemblyByName(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.ExecuteAssemblyByName(System.String, System.Security.Policy.Evidence, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.Load(System.Byte[], System.Byte[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.Load(System.Reflection.AssemblyName, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.Load(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.PermissionSet.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.SetAppDomainPolicy(System.Security.Policy.PolicyLevel)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.SetData(System.String, System.Object, System.Security.IPermission)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.AppDomain.SetupInformation.get()' does not exist in the implementation but it does exist in the contract
-MembersMustExist : Member 'System.Collections.Hashtable System.Resources.ResourceManager.ResourceSets' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Hashtable System.Resources.ResourceSet.Table' does not exist in the implementation but it does exist in the contract
-MembersMustExist : Member 'System.ComponentModel.AsyncCompletedEventArgs..ctor()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.Common.DbProviderFactory.CreatePermission(System.Security.Permissions.PermissionState)' does not exist in the implementation but it does exist in the contract
-MembersMustExist : Member 'System.Diagnostics.Debug.Listeners.get()' does not exist in the implementation but it does exist in the contract
-MembersMustExist : Member 'System.IO.Directory.CreateDirectory(System.String, System.Security.AccessControl.DirectorySecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.GetAccessControl(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.GetAccessControl(System.String, System.Security.AccessControl.AccessControlSections)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.SetAccessControl(System.String, System.Security.AccessControl.DirectorySecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.Create(System.Security.AccessControl.DirectorySecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.CreateSubdirectory(System.String, System.Security.AccessControl.DirectorySecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.GetAccessControl(System.Security.AccessControl.AccessControlSections)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.SetAccessControl(System.Security.AccessControl.DirectorySecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.Create(System.String, System.Int32, System.IO.FileOptions, System.Security.AccessControl.FileSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.GetAccessControl(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.GetAccessControl(System.String, System.Security.AccessControl.AccessControlSections)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.SetAccessControl(System.String, System.Security.AccessControl.FileSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.FileInfo.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.FileInfo.GetAccessControl(System.Security.AccessControl.AccessControlSections)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.FileInfo.SetAccessControl(System.Security.AccessControl.FileSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.FileStream..ctor(System.String, System.IO.FileMode, System.Security.AccessControl.FileSystemRights, System.IO.FileShare, System.Int32, System.IO.FileOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.FileStream..ctor(System.String, System.IO.FileMode, System.Security.AccessControl.FileSystemRights, System.IO.FileShare, System.Int32, System.IO.FileOptions, System.Security.AccessControl.FileSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.FileStream.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.FileStream.SetAccessControl(System.Security.AccessControl.FileSecurity)' does not exist in the implementation but it does exist in the contract
-MembersMustExist : Member 'System.IO.MemoryMappedFiles.MemoryMappedFile.CreateFromFile(System.IO.FileStream, System.String, System.Int64, System.IO.MemoryMappedFiles.MemoryMappedFileAccess, System.IO.MemoryMappedFiles.MemoryMappedFileSecurity, System.IO.HandleInheritability, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.MemoryMappedFiles.MemoryMappedFile.CreateNew(System.String, System.Int64, System.IO.MemoryMappedFiles.MemoryMappedFileAccess, System.IO.MemoryMappedFiles.MemoryMappedFileOptions, System.IO.MemoryMappedFiles.MemoryMappedFileSecurity, System.IO.HandleInheritability)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.MemoryMappedFiles.MemoryMappedFile.CreateOrOpen(System.String, System.Int64, System.IO.MemoryMappedFiles.MemoryMappedFileAccess, System.IO.MemoryMappedFiles.MemoryMappedFileOptions, System.IO.MemoryMappedFiles.MemoryMappedFileSecurity, System.IO.HandleInheritability)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.MemoryMappedFiles.MemoryMappedFile.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.MemoryMappedFiles.MemoryMappedFile.SetAccessControl(System.IO.MemoryMappedFiles.MemoryMappedFileSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Pipes.AnonymousPipeServerStream..ctor(System.IO.Pipes.PipeDirection, System.IO.HandleInheritability, System.Int32, System.IO.Pipes.PipeSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Pipes.NamedPipeClientStream..ctor(System.String, System.String, System.IO.Pipes.PipeAccessRights, System.IO.Pipes.PipeOptions, System.Security.Principal.TokenImpersonationLevel, System.IO.HandleInheritability)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Pipes.NamedPipeServerStream..ctor(System.String, System.IO.Pipes.PipeDirection, System.Int32, System.IO.Pipes.PipeTransmissionMode, System.IO.Pipes.PipeOptions, System.Int32, System.Int32, System.IO.Pipes.PipeSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Pipes.NamedPipeServerStream..ctor(System.String, System.IO.Pipes.PipeDirection, System.Int32, System.IO.Pipes.PipeTransmissionMode, System.IO.Pipes.PipeOptions, System.Int32, System.Int32, System.IO.Pipes.PipeSecurity, System.IO.HandleInheritability)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Pipes.NamedPipeServerStream..ctor(System.String, System.IO.Pipes.PipeDirection, System.Int32, System.IO.Pipes.PipeTransmissionMode, System.IO.Pipes.PipeOptions, System.Int32, System.Int32, System.IO.Pipes.PipeSecurity, System.IO.HandleInheritability, System.IO.Pipes.PipeAccessRights)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Pipes.PipeStream.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Pipes.PipeStream.SetAccessControl(System.IO.Pipes.PipeSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Linq.Expressions.LambdaExpression.CompileToMethod(System.Reflection.Emit.MethodBuilder)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Linq.Expressions.LambdaExpression.CompileToMethod(System.Reflection.Emit.MethodBuilder, System.Runtime.CompilerServices.DebugInfoGenerator)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.MarshalByRefObject.CreateObjRef(System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpVersion..ctor()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpWebRequest..ctor()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.ServicePointManager.CertificatePolicy.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.ServicePointManager.CertificatePolicy.set(System.Net.ICertificatePolicy)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.SocketAsyncEventArgs.SocketClientAccessPolicyProtocol.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.SocketAsyncEventArgs.SocketClientAccessPolicyProtocol.set(System.Net.Sockets.SocketClientAccessPolicyProtocol)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.SocketFlags System.Net.Sockets.SocketFlags.MaxIOVectorLength' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.TransportContext.GetTlsTokenBindings()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.WebRequest.CreatorInstance.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.WebRequest.RegisterPortableWebRequestCreator(System.Net.IWebRequestCreate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.Evidence.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.Load(System.Byte[], System.Byte[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.Load(System.Byte[], System.Byte[], System.Security.SecurityContextSource)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.Load(System.Reflection.AssemblyName, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.Load(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.LoadFile(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.LoadFrom(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.LoadFrom(System.String, System.Security.Policy.Evidence, System.Byte[], System.Configuration.Assemblies.AssemblyHashAlgorithm)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.LoadWithPartialName(System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.PermissionSet.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Module.GetSignerCertificate()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Resources.IResourceReader System.Resources.ResourceSet.Reader' does not exist in the implementation but it does exist in the contract
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetActiveObject(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetComInterfaceForObjectInContext(System.Object, System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetComSlotForMethodInfo(System.Reflection.MemberInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetEndComSlot(System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetExceptionPointers()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetIDispatchForObjectInContext(System.Object)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetITypeInfoForType(System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetIUnknownForObjectInContext(System.Object)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetManagedThunkForUnmanagedMethodPtr(System.IntPtr, System.IntPtr, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetMethodInfoForComSlot(System.Type, System.Int32, System.Runtime.InteropServices.ComMemberType)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetThreadFromFiberCookie(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeForITypeInfo(System.IntPtr)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeInfoName(System.Runtime.InteropServices.UCOMITypeInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibGuid(System.Runtime.InteropServices.ComTypes.ITypeLib)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibGuid(System.Runtime.InteropServices.UCOMITypeLib)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibGuidForAssembly(System.Reflection.Assembly)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibLcid(System.Runtime.InteropServices.ComTypes.ITypeLib)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibLcid(System.Runtime.InteropServices.UCOMITypeLib)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibName(System.Runtime.InteropServices.ComTypes.ITypeLib)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibName(System.Runtime.InteropServices.UCOMITypeLib)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetTypeLibVersionForAssembly(System.Reflection.Assembly, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.GetUnmanagedThunkForManagedMethodPtr(System.IntPtr, System.IntPtr, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.IsTypeVisibleFromCom(System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.NumParamBytes(System.Reflection.MethodInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.ReleaseThreadCache()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.RuntimeEnvironment..ctor()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializer..ctor(System.Type, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializer..ctor(System.Type, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate, System.Runtime.Serialization.DataContractResolver)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializer..ctor(System.Type, System.String, System.String, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializer..ctor(System.Type, System.String, System.String, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate, System.Runtime.Serialization.DataContractResolver)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializer..ctor(System.Type, System.Xml.XmlDictionaryString, System.Xml.XmlDictionaryString, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializer..ctor(System.Type, System.Xml.XmlDictionaryString, System.Xml.XmlDictionaryString, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate, System.Runtime.Serialization.DataContractResolver)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializer.DataContractSurrogate.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializerSettings.DataContractSurrogate.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.DataContractSerializerSettings.DataContractSurrogate.set(System.Runtime.Serialization.IDataContractSurrogate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.ExportOptions.DataContractSurrogate.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.ExportOptions.DataContractSurrogate.set(System.Runtime.Serialization.IDataContractSurrogate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(System.IO.Stream, System.Runtime.Remoting.Messaging.HeaderHandler)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.DeserializeMethodResponse(System.IO.Stream, System.Runtime.Remoting.Messaging.HeaderHandler, System.Runtime.Remoting.Messaging.IMethodCallMessage)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Serialize(System.IO.Stream, System.Object, System.Runtime.Remoting.Messaging.Header[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.UnsafeDeserialize(System.IO.Stream, System.Runtime.Remoting.Messaging.HeaderHandler)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.UnsafeDeserializeMethodResponse(System.IO.Stream, System.Runtime.Remoting.Messaging.HeaderHandler, System.Runtime.Remoting.Messaging.IMethodCallMessage)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Json.DataContractJsonSerializer..ctor(System.Type, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Json.DataContractJsonSerializer..ctor(System.Type, System.String, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Json.DataContractJsonSerializer..ctor(System.Type, System.Xml.XmlDictionaryString, System.Collections.Generic.IEnumerable<System.Type>, System.Int32, System.Boolean, System.Runtime.Serialization.IDataContractSurrogate, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Json.DataContractJsonSerializer.DataContractSurrogate.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Json.DataContractJsonSerializerSettings.DataContractSurrogate.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.Serialization.Json.DataContractJsonSerializerSettings.DataContractSurrogate.set(System.Runtime.Serialization.IDataContractSurrogate)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.CspKeyContainerInfo.CryptoKeySecurity.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.CspParameters..ctor(System.Int32, System.String, System.String, System.Security.AccessControl.CryptoKeySecurity, System.IntPtr)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.CspParameters..ctor(System.Int32, System.String, System.String, System.Security.AccessControl.CryptoKeySecurity, System.Security.SecureString)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.CspParameters.CryptoKeySecurity.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.CspParameters.CryptoKeySecurity.set(System.Security.AccessControl.CryptoKeySecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException..ctor(System.String, System.Object, System.Object, System.Reflection.MethodInfo, System.Object, System.Security.IPermission)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException..ctor(System.String, System.Reflection.AssemblyName, System.Security.PermissionSet, System.Security.PermissionSet, System.Reflection.MethodInfo, System.Security.Permissions.SecurityAction, System.Object, System.Security.IPermission, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException.Action.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException.Action.set(System.Security.Permissions.SecurityAction)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException.FirstPermissionThatFailed.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException.FirstPermissionThatFailed.set(System.Security.IPermission)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException.Zone.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.SecurityException.Zone.set(System.Security.SecurityZone)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Thread.CurrentContext.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String System.Resources.ResourceManager.BaseNameField' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.EventWaitHandle..ctor(System.Boolean, System.Threading.EventResetMode, System.String, System.Boolean, System.Security.AccessControl.EventWaitHandleSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.EventWaitHandle.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.EventWaitHandle.OpenExisting(System.String, System.Security.AccessControl.EventWaitHandleRights)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.EventWaitHandle.SetAccessControl(System.Security.AccessControl.EventWaitHandleSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.EventWaitHandle.TryOpenExisting(System.String, System.Security.AccessControl.EventWaitHandleRights, System.Threading.EventWaitHandle)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Mutex..ctor(System.Boolean, System.String, System.Boolean, System.Security.AccessControl.MutexSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Mutex.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Mutex.OpenExisting(System.String, System.Security.AccessControl.MutexRights)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Mutex.SetAccessControl(System.Security.AccessControl.MutexSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Mutex.TryOpenExisting(System.String, System.Security.AccessControl.MutexRights, System.Threading.Mutex)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Semaphore..ctor(System.Int32, System.Int32, System.String, System.Boolean, System.Security.AccessControl.SemaphoreSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Semaphore.GetAccessControl()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Semaphore.OpenExisting(System.String, System.Security.AccessControl.SemaphoreRights)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Semaphore.SetAccessControl(System.Security.AccessControl.SemaphoreSecurity)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Semaphore.TryOpenExisting(System.String, System.Security.AccessControl.SemaphoreRights, System.Threading.Semaphore)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlMemberMapping.GenerateTypeName(System.CodeDom.Compiler.CodeDomProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSchemaImporter..ctor(System.Xml.Serialization.XmlSchemas, System.Xml.Serialization.CodeGenerationOptions, System.CodeDom.Compiler.CodeDomProvider, System.Xml.Serialization.ImportContext)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSchemaImporter..ctor(System.Xml.Serialization.XmlSchemas, System.Xml.Serialization.CodeGenerationOptions, System.Xml.Serialization.ImportContext)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSchemaImporter..ctor(System.Xml.Serialization.XmlSchemas, System.Xml.Serialization.CodeIdentifiers, System.Xml.Serialization.CodeGenerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSerializer..ctor(System.Type, System.Xml.Serialization.XmlAttributeOverrides, System.Type[], System.Xml.Serialization.XmlRootAttribute, System.String, System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSerializer.FromMappings(System.Xml.Serialization.XmlMapping[], System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSerializer.GenerateSerializer(System.Type[], System.Xml.Serialization.XmlMapping[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSerializer.GenerateSerializer(System.Type[], System.Xml.Serialization.XmlMapping[], System.CodeDom.Compiler.CompilerParameters)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.XmlSerializerFactory.CreateSerializer(System.Type, System.Xml.Serialization.XmlAttributeOverrides, System.Type[], System.Xml.Serialization.XmlRootAttribute, System.String, System.String, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.XmlReaderSettings..ctor(System.Xml.XmlResolver)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.XmlSecureResolver..ctor(System.Xml.XmlResolver, System.Security.PermissionSet)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.XmlSecureResolver..ctor(System.Xml.XmlResolver, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.XmlSecureResolver.CreateEvidenceForUrl(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Xsl.XslCompiledTransform.CompileToType(System.Xml.XmlReader, System.Xml.Xsl.XsltSettings, System.Xml.XmlResolver, System.Boolean, System.Reflection.Emit.TypeBuilder, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Xsl.XslCompiledTransform.TemporaryFiles.get()' does not exist in the implementation but it does exist in the contract
-MembersMustExist : Member 'System.Xml.Xsl.XslTransform.Load(System.Xml.XmlReader, System.Xml.XmlResolver, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Xsl.XslTransform.Load(System.Xml.XPath.IXPathNavigable, System.Xml.XmlResolver, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Xsl.XslTransform.Load(System.Xml.XPath.XPathNavigator, System.Xml.XmlResolver, Syste
-
-// Negligible usage, CAS
-TypesMustExist : Type 'System.ServiceProcess.ServiceControllerPermission' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.ServiceControllerPermissionAccess' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.ServiceControllerPermissionAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.ServiceControllerPermissionEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.ServiceControllerPermissionEntryCollection' does not exist in the implementation but it does exist in the contract.
-
-// CAS
-TypesMustExist : Type 'System.Security.Policy.ApplicationSecurityInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Policy.ApplicationSecurityManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Policy.IApplicationTrustManager' does not exist in the implementation but it does exist in the contract.
-
-// Undesirable dependencies
-TypesMustExist : Type 'System.ServiceProcess.Design.ServiceInstallerDialog' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.Design.ServiceInstallerDialogResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.ServiceInstaller' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.ServiceProcessDescriptionAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceProcess.ServiceProcessInstaller' does not exist in the implementation but it does exist in the contract.
-
-MembersMustExist : Member 'System.Console.Write(System.String, System.Object, System.Object, System.Object, System.Object, __arglist)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Console.WriteLine(System.String, System.Object, System.Object, System.Object, System.Object, __arglist)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Concat(System.Object, System.Object, System.Object, System.Object, __arglist)' does not exist in the implementation but it does exist in the contract.
-
-// Intentional change in Core
-TypeCannotChangeClassification : Type 'System.RuntimeArgumentHandle' is a 'ref struct' in the implementation but is a 'struct' in the contract.
-TypeCannotChangeClassification : Type 'System.TypedReference' is a 'ref struct' in the implementation but is a 'struct' in the contract.
\ No newline at end of file
diff --git a/src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.txt b/src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.txt
deleted file mode 100644
index 4fd3fa2437be4f..00000000000000
--- a/src/libraries/shims/ApiCompatBaseline.netcoreapp.netfx461.txt
+++ /dev/null
@@ -1,614 +0,0 @@
-ApiCompat Error: 0 : Unable to resolve assembly 'Assembly(Name=System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089)' referenced by the contract assembly 'Assembly(Name=System.ServiceModel.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35)'.
-ApiCompat Error: 0 : Unable to resolve assembly 'Assembly(Name=System.Web.ApplicationServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35)' referenced by the contract assembly 'Assembly(Name=System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a)'.
-ApiCompat Error: 0 : Unable to resolve assembly 'Assembly(Name=System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089)' referenced by the contract assembly 'Assembly(Name=System.Xml.Serialization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089)'.
-ApiCompat Error: 0 : Unable to resolve assembly 'Assembly(Name=System.Xaml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089)' referenced by the contract assembly 'Assembly(Name=WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35)'.
-Compat issues with assembly mscorlib:
-TypesMustExist : Type 'System.Configuration.Assemblies.AssemblyHash' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.IsolatedStorage.IsolatedStorageSecurityOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.IsolatedStorage.IsolatedStorageSecurityState' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.EventToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.ExceptionHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.FieldToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.MethodRental' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.MethodToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.ParameterToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.PEFileKinds' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.PropertyToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.SignatureToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.StringToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.TypeToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.UnmanagedMarshal' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.ProfileOptimization' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Formatters.InternalRM' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Formatters.InternalST' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Formatters.ISoapMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Formatters.ServerFault' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Formatters.SoapFault' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Formatters.SoapMessage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Principal.WindowsImpersonationContext' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System:
-MembersMustExist : Member 'System.CodeDom.Compiler.CompilerParameters.Evidence.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.CodeDom.Compiler.CompilerParameters.Evidence.set(System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.CodeDom.Compiler.CompilerResults.Evidence.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.CodeDom.Compiler.CompilerResults.Evidence.set(System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.ConsoleTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.DiagnosticsConfigurationHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.EventLogTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.XmlWriterTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.IODescriptionAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.ICertificatePolicy' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.AuthenticationModuleElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.AuthenticationModuleElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.AuthenticationModulesSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.BypassElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.BypassElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.ConnectionManagementElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.ConnectionManagementElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.ConnectionManagementSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.DefaultProxySection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.FtpCachePolicyElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.HttpCachePolicyElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.HttpListenerElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.HttpListenerTimeoutsElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.HttpWebRequestElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.Ipv6Element' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.MailSettingsSectionGroup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.ModuleElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.NetSectionGroup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.PerformanceCountersElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.ProxyElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.RequestCachingSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.ServicePointManagerElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.SettingsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.SmtpNetworkElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.SmtpSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.SmtpSpecifiedPickupDirectoryElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.SocketElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.UnicodeDecodingConformance' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.UnicodeEncodingConformance' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.WebProxyScriptElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.WebRequestModuleElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.WebRequestModuleElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.WebRequestModulesSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Configuration.WebUtilityElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Sockets.SocketClientAccessPolicyProtocol' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.ICustomTypeProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.StandardOleMarshalObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Authentication.ExtendedProtection.TokenBinding' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Authentication.ExtendedProtection.TokenBindingType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Authentication.ExtendedProtection.Configuration.ExtendedProtectionPolicyElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Authentication.ExtendedProtection.Configuration.ServiceNameElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Authentication.ExtendedProtection.Configuration.ServiceNameElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Claims.DynamicRoleClaimProvider' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.ComponentModel.DataAnnotations:
-TypesMustExist : Type 'System.ComponentModel.DataAnnotations.AssociatedMetadataTypeTypeDescriptionProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.DataAnnotations.BindableTypeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.DataAnnotations.MetadataTypeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.DataAnnotations.ScaffoldTableAttribute' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Core:
-TypesMustExist : Type 'System.Diagnostics.EventSchemaTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.TraceLogRetentionOption' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.UnescapedXmlDiagnosticData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.EventDescriptor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.EventProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.EventProviderTraceListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventBookmark' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventKeyword' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogConfiguration' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogInvalidDataException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogIsolation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogLink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogNotFoundException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogPropertySelector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogProviderDisabledException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogQuery' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogReader' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogReadingException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogRecord' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogSession' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventLogWatcher' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventMetadata' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventOpcode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventRecord' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventRecordWrittenEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.EventTask' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.PathType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.ProviderMetadata' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.SessionAuthentication' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.StandardEventKeywords' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.StandardEventLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.StandardEventOpcode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Eventing.Reader.StandardEventTask' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PerformanceData.CounterData' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PerformanceData.CounterSet' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PerformanceData.CounterSetInstance' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PerformanceData.CounterSetInstanceCounterDataSet' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PerformanceData.CounterSetInstanceType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PerformanceData.CounterType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.MemoryMappedFiles.MemoryMappedFileSecurity' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.InstanceNotFoundException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.InstrumentationBaseException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.InstrumentationException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementBindAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementCommitAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementConfigurationAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementConfigurationType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementCreateAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementEntityAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementEnumeratorAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementHostingModel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementKeyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementMemberAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementNameAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementNewInstanceAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementProbeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementReferenceAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementRemoveAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.ManagementTaskAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Management.Instrumentation.WmiConfigurationAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.CallSiteOps' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.Closure' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ExecutionScope' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.RuntimeOps' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.ManifestKinds' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.ManifestSignatureInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.ManifestSignatureInformationCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.MD5Cng' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.SHA1Cng' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.SHA256Cng' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.SHA384Cng' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.SHA512Cng' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.SignatureVerificationResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.StrongNameSignatureInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.AuthenticodeSignatureInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.TimestampInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.TrustStatus' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Data:
-TypesMustExist : Type 'Microsoft.SqlServer.Server.SqlContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'Microsoft.SqlServer.Server.SqlFacetAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'Microsoft.SqlServer.Server.SqlPipe' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'Microsoft.SqlServer.Server.SqlProcedureAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'Microsoft.SqlServer.Server.SqlTriggerAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'Microsoft.SqlServer.Server.SqlTriggerContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'Microsoft.SqlServer.Server.TriggerAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.DataSetSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.PropertyAttributes' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.TypedDataSetGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.TypedDataSetGeneratorException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.Common.DbProviderConfigurationHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.Common.DbProviderFactoriesConfigurationHandler' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.Common.DbProviderFactory.CreatePermission(System.Security.Permissions.PermissionState)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.Odbc.OdbcConnection.EnlistDistributedTransaction(System.EnterpriseServices.ITransaction)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.Odbc.OdbcFactory.CreatePermission(System.Security.Permissions.PermissionState)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.Sql.SqlDataSourceEnumerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SqlAuthenticationMethod' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlBulkCopyOptions System.Data.SqlClient.SqlBulkCopyOptions.AllowEncryptedValueModifications' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlClientFactory.CreatePermission(System.Security.Permissions.PermissionState)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SqlColumnEncryptionCertificateStoreProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SqlColumnEncryptionCngProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SqlColumnEncryptionCspProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SqlColumnEncryptionKeyStoreProvider' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand..ctor(System.String, System.Data.SqlClient.SqlConnection, System.Data.SqlClient.SqlTransaction, System.Data.SqlClient.SqlCommandColumnEncryptionSetting)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.BeginExecuteReader()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.BeginExecuteReader(System.AsyncCallback, System.Object)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.BeginExecuteReader(System.AsyncCallback, System.Object, System.Data.CommandBehavior)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.BeginExecuteReader(System.Data.CommandBehavior)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.ColumnEncryptionSetting.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.EndExecuteReader(System.IAsyncResult)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.NotificationAutoEnlist.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlCommand.NotificationAutoEnlist.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SqlCommandColumnEncryptionSetting' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnection.AccessToken.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnection.AccessToken.set(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnection.ColumnEncryptionTrustedMasterKeyPaths.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnection.EnlistDistributedTransaction(System.EnterpriseServices.ITransaction)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnection.RegisterColumnEncryptionKeyStoreProviders(System.Collections.Generic.IDictionary<System.String, System.Data.SqlClient.SqlColumnEncryptionKeyStoreProvider>)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SqlConnectionColumnEncryptionSetting' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.AsynchronousProcessing.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.AsynchronousProcessing.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.Authentication.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.Authentication.set(System.Data.SqlClient.SqlAuthenticationMethod)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.ColumnEncryptionSetting.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.ColumnEncryptionSetting.set(System.Data.SqlClient.SqlConnectionColumnEncryptionSetting)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.ConnectionReset.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.ConnectionReset.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.ContextConnection.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.ContextConnection.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.NetworkLibrary.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.NetworkLibrary.set(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.TransparentNetworkIPResolution.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlConnectionStringBuilder.TransparentNetworkIPResolution.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlClient.SQLDebugging' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlParameter.ForceColumnEncryption.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlParameter.ForceColumnEncryption.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Data.SqlClient.SqlParameterCollection.Add(System.String, System.Object)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.SqlFileStream' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.SqlTypesSchemaImporterExtensionHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeBigIntSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeBinarySchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeBitSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeCharSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeDateTimeSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeDecimalSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeFloatSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeIntSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeMoneySchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeNCharSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeNTextSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeNumericSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeNVarCharSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeRealSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeSmallDateTimeSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeSmallIntSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeSmallMoneySchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeTextSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeTinyIntSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeUniqueIdentifierSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeVarBinarySchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeVarCharSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Data.SqlTypes.TypeVarImageSchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.XmlDataDocument' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.DirectoryServices:
-TypesMustExist : Type 'System.DirectoryServices.DSDescriptionAttribute' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.DirectoryServices.Protocols:
-MembersMustExist : Member 'System.DirectoryServices.Protocols.AddRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-CannotMakeTypeAbstract : Type 'System.DirectoryServices.Protocols.BerConverter' is abstract in the implementation but is not abstract in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.CompareRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.DeleteRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.DirectoryRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.DsmlAuthRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlAuthResponse' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlDirectoryIdentifier' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlDocument' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlDocumentProcessing' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlErrorProcessing' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlErrorResponse' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlInvalidDocumentException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlRequestDocument' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlResponseDocument' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlResponseOrder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlSoapConnection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.DsmlSoapHttpConnection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.ErrorResponseCategory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.DirectoryServices.Protocols.ErrorResponseException' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.ExtendedRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.ModifyDNRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.ModifyRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.SearchRequest..ctor(System.String, System.Xml.XmlDocument, System.DirectoryServices.Protocols.SearchScope, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DirectoryServices.Protocols.SearchRequest.ToXmlNode(System.Xml.XmlDocument)' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Drawing:
-CannotMakeTypeAbstract : Type 'System.Drawing.ColorTranslator' is abstract in the implementation but is not abstract in the contract.
-TypesMustExist : Type 'System.Drawing.FontConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.IconConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.ImageConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.ImageFormatConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.IPropertyValueUIService' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.IToolboxItemProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.IToolboxService' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.IToolboxUser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.PaintValueEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.PropertyValueUIHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.PropertyValueUIItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.PropertyValueUIItemInvokeHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.ToolboxComponentsCreatedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.ToolboxComponentsCreatedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.ToolboxComponentsCreatingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.ToolboxComponentsCreatingEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.ToolboxItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.ToolboxItemCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.ToolboxItemCreatorCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.UITypeEditor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Design.UITypeEditorEditStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.Printing.MarginsConverter' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Net:
-TypesMustExist : Type 'System.Net.INetworkProgress' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.IPEndPointCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.IUnsafeWebRequestCreate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.NetworkProgressChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.UiSynchronizationContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Cloud' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.CloudCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.PeerName' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.PeerNameRecord' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.PeerNameRecordCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.PeerNameRegistration' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.PeerNameResolver' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.PeerNameType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.PeerToPeerException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.ResolveCompletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.ResolveProgressChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.ApplicationChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.ContactManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.CreateContactCompletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.InviteCompletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.NameChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.ObjectChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.Peer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerApplication' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerApplicationCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerApplicationLaunchInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerApplicationRegistrationType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerChangeType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerCollaboration' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerContact' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerContactCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerEndPoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerEndPointCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerInvitationResponse' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerInvitationResponseType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerNearMe' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerNearMeChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerNearMeCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerObjectCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerPresenceInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerPresenceStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PeerScope' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.PresenceChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.RefreshDataCompletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.SubscribeCompletedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.SubscriptionListChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.PeerToPeer.Collaboration.SubscriptionType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Sockets.HttpPolicyDownloaderProtocol' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Sockets.SecurityCriticalAction' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Sockets.SocketPolicy' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Sockets.UdpAnySourceMulticastClient' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Sockets.UdpSingleSourceMulticastClient' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Runtime.Serialization:
-TypesMustExist : Type 'System.Runtime.Serialization.IDataContractSurrogate' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.ImportOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.NetDataContractSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.XsdDataContractImporter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.DataContractSerializerSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.DeclaredTypeElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.DeclaredTypeElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.NetDataContractSerializerSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.ParameterElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.ParameterElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.SerializationSectionGroup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.TypeElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.Serialization.Configuration.TypeElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.IXmlMtomReaderInitializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.IXmlMtomWriterInitializer' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Security:
-TypesMustExist : Type 'System.Security.Cryptography.DataProtector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.DpapiDataProtector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.MemoryProtectionScope' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.ProtectedMemory' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.Pkcs.AlgorithmIdentifier.Parameters.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.Pkcs.AlgorithmIdentifier.Parameters.set(System.Byte[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.Pkcs.EnvelopedCms..ctor(System.Security.Cryptography.Pkcs.SubjectIdentifierType, System.Security.Cryptography.Pkcs.ContentInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.Pkcs.EnvelopedCms..ctor(System.Security.Cryptography.Pkcs.SubjectIdentifierType, System.Security.Cryptography.Pkcs.ContentInfo, System.Security.Cryptography.Pkcs.AlgorithmIdentifier)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.Pkcs.EnvelopedCms.Encrypt()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.Pkcs.KeyAgreeKeyChoice' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.X509Certificate2UI' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.X509SelectionFlag' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.ServiceModel.Web:
-TypesMustExist : Type 'System.ServiceModel.WebHttpBinding' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.WebHttpSecurity' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.WebHttpSecurityMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Activation.WebScriptServiceHostFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Activation.WebServiceHostFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Channels.JavascriptCallbackResponseMessageProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Channels.StreamBodyWriter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Channels.WebBodyFormatMessageProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Channels.WebContentFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Channels.WebContentTypeMapper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Channels.WebMessageEncodingBindingElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebHttpBindingCollectionElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebHttpBindingElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebHttpElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebHttpEndpointCollectionElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebHttpEndpointElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebHttpSecurityElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebMessageEncodingElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebScriptEnablingElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebScriptEndpointCollectionElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Configuration.WebScriptEndpointElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Description.JsonFaultDetail' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Description.WebHttpBehavior' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Description.WebHttpEndpoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Description.WebScriptEnablingBehavior' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Description.WebScriptEndpoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Description.WebServiceEndpoint' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Dispatcher.JsonQueryStringConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Dispatcher.QueryStringConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Dispatcher.WebHttpDispatchOperationSelector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.AspNetCacheProfileAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.IncomingWebRequestContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.IncomingWebResponseContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.JavascriptCallbackBehaviorAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.OutgoingWebRequestContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.OutgoingWebResponseContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebChannelFactory<TChannel>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebFaultException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebFaultException<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebGetAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebInvokeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebMessageBodyStyle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebMessageFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebOperationContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ServiceModel.Web.WebServiceHost' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.ServiceProcess:
-TypesMustExist : Type 'System.ServiceProcess.ServiceAccount' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Transactions:
-TypesMustExist : Type 'System.Transactions.Configuration.DefaultSettingsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Transactions.Configuration.MachineSettingsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Transactions.Configuration.TransactionsSectionGroup' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Xml:
-TypesMustExist : Type 'System.Xml.XmlXapResolver' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.CodeExporter' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Serialization.SchemaImporter.Extensions.get()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.SoapCodeExporter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.SoapSchemaExporter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.SoapSchemaImporter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.XmlCodeExporter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Advanced.SchemaImporterExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Advanced.SchemaImporterExtensionCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Configuration.DateTimeSerializationSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Configuration.RootedPathValidator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Configuration.SchemaImporterExtensionElement' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Configuration.SchemaImporterExtensionElementCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Configuration.SchemaImporterExtensionsSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Configuration.SerializationSectionGroup' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.Configuration.XmlSerializerSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.XmlConfiguration.XmlReaderSection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.XmlConfiguration.XsltConfigSection' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Xsl.XslCompiledTransform.TemporaryFiles.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Xsl.XslTransform.Load(System.Xml.XPath.XPathNavigator, System.Xml.XmlResolver, System.Security.Policy.Evidence)' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly WindowsBase:
-TypesMustExist : Type 'System.Collections.Specialized.CollectionChangedEventManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.CurrentChangedEventManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.CurrentChangingEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.CurrentChangingEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.CurrentChangingEventManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.DependencyPropertyDescriptor' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.ErrorsChangedEventManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.GroupDescription' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.ICollectionView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.ICollectionViewFactory' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.ICollectionViewLiveShaping' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.IEditableCollectionView' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.IEditableCollectionViewAddNewItem' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.IItemProperties' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.ItemPropertyInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.NewItemPlaceholderPosition' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.PropertyChangedEventManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.PropertyFilterAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.PropertyFilterOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.SortDescription' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ComponentModel.SortDescriptionCollection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PresentationTraceLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.PresentationTraceSources' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.CertificateEmbeddingOption' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.EncryptedPackageEnvelope' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.InvalidSignatureEventHandler' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Packaging.Package..ctor(System.IO.FileAccess, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.PackageDigitalSignature' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.PackageDigitalSignatureManager' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Packaging.PackUriHelper.ComparePackUri(System.Uri, System.Uri)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Packaging.PackUriHelper.Create(System.Uri)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Packaging.PackUriHelper.Create(System.Uri, System.Uri)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Packaging.PackUriHelper.Create(System.Uri, System.Uri, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Packaging.PackUriHelper.GetPackageUri(System.Uri)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Packaging.PackUriHelper.GetPartUri(System.Uri)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.RightsManagementInformation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.SignatureVerificationEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.StorageInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.StreamInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Packaging.VerifyResult' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.MediaPermission' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.MediaPermissionAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.MediaPermissionAudio' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.MediaPermissionImage' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.MediaPermissionVideo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.WebBrowserPermission' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.WebBrowserPermissionAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Permissions.WebBrowserPermissionLevel' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.AuthenticationType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.ContentGrant' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.ContentRight' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.ContentUser' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.CryptoProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.LocalizedNameDescriptionPair' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.PublishLicense' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.RightsManagementException' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.RightsManagementFailureCode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.SecureEnvironment' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.UnsignedPublishLicense' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.UseLicense' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.RightsManagement.UserActivationMode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.AttachedPropertyBrowsableAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.AttachedPropertyBrowsableForTypeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.AttachedPropertyBrowsableWhenAttributePresentAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.BaseCompatibilityPreferences' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.CoerceValueCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.DependencyObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.DependencyObjectType' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.DependencyProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.DependencyPropertyChangedEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.DependencyPropertyChangedEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.DependencyPropertyKey' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Expression' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.ExpressionConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Freezable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Int32Rect' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Int32RectConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.IWeakEventListener' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.LocalValueEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.LocalValueEnumerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.NameScope' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Point' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.PointConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.PropertyChangedCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.PropertyMetadata' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Rect' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.RectConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Size' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.SizeConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.SplashScreen' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.ValidateValueCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Vector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.VectorConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.WeakEventManager' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.WeakEventManager<TEventSource, TEventArgs>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Converters.Int32RectValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Converters.PointValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Converters.RectValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Converters.SizeValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Converters.VectorValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Data.DataSourceProvider' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.FocusNavigationDirection' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.Key' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.KeyConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.KeyInterop' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.KeyValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.ModifierKeys' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.ModifierKeysConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.ModifierKeysValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Input.TraversalRequest' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Interop.ComponentDispatcher' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Interop.IKeyboardInputSink' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Interop.IKeyboardInputSite' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Interop.MSG' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Interop.ThreadMessageEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.DesignerSerializationOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.DesignerSerializationOptionsAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.InternalTypeHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.IReceiveMarkupExtension' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.ServiceProviders' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.Primitives.MarkupObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Markup.Primitives.MarkupProperty' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Media.DisableDpiAwarenessAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Media.Matrix' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Media.MatrixConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Media.Converters.MatrixValueSerializer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.Dispatcher' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherFrame' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherHookEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherHookEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherHooks' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherObject' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherOperation' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherOperation<TResult>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherOperationCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherOperationStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherPriority' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherPriorityAwaitable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherPriorityAwaiter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherProcessingDisabled' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherSynchronizationContext' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherTimer' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherUnhandledExceptionEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherUnhandledExceptionEventHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Windows.Threading.DispatcherUnhandledExceptionFilterEventHandler' does not exist in the implementation but it does exist in the contract.
-Total Issues: 633
diff --git a/src/libraries/shims/ApiCompatBaseline.netfx.netstandard.txt b/src/libraries/shims/ApiCompatBaseline.netfx.netstandard.txt
deleted file mode 100644
index e185b0e6f6de75..00000000000000
--- a/src/libraries/shims/ApiCompatBaseline.netfx.netstandard.txt
+++ /dev/null
@@ -1,102 +0,0 @@
-Compat issues with assembly mscorlib:
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinAccountReadonlyControllersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinApplicationPackageAuthoritySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinAnyPackageSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinCertSvcDComAccessGroup' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinCryptoOperatorsSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinDCOMUsersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinEventLogReadersGroup' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinIUsersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCacheablePrincipalsGroupSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityDocumentsLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityEnterpriseAuthenticationSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityInternetClientServerSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityInternetClientSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityMusicLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityPicturesLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityPrivateNetworkClientServerSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityRemovableStorageSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilitySharedUserCertificatesSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityVideosLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinConsoleLogonSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCreatorOwnerRightsSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinEnterpriseReadonlyControllersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinHighLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinIUserSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinLocalLogonSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinLowLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinMediumLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinMediumPlusLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinNewEnterpriseReadonlyControllersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinNonCacheablePrincipalsGroupSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinSystemLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinThisOrganizationCertificateSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinUntrustedLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinWriteRestrictedCodeSid' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.ComponentModel.Annotations:
-CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'System.ComponentModel.DataAnnotations.DisplayAttribute' changed from '[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property, AllowMultiple=false)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property, AllowMultiple=false)]' in the implementation.
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.DisplayFormatAttribute.GetNullDisplayText()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.DisplayFormatAttribute.NullDisplayTextResourceType.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.DisplayFormatAttribute.NullDisplayTextResourceType.set(System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.RangeAttribute.ConvertValueInInvariantCulture.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.RangeAttribute.ConvertValueInInvariantCulture.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.RangeAttribute.ParseLimitsInInvariantCulture.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DataAnnotations.RangeAttribute.ParseLimitsInInvariantCulture.set(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.ComponentModel.Composition:
-TypesMustExist : Type 'System.ComponentModel.Composition.AdaptationConstants' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Configuration.ConfigurationManager:
-MembersMustExist : Member 'System.Configuration.Internal.DelegatingConfigHost.HasLocalConfig.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Configuration.Internal.DelegatingConfigHost.HasRoamingConfig.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Configuration.Internal.DelegatingConfigHost.IsAppConfigHttp.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Configuration.Internal.DelegatingConfigHost.RefreshConfigPaths()' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Diagnostics.PerformanceCounter:
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Diagnostics.CounterSample' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Diagnostics.CounterSample' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-Compat issues with assembly System.Security.Cryptography.OpenSsl:
-TypesMustExist : Type 'System.Security.Cryptography.DSAOpenSsl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.ECDsaOpenSsl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.RSAOpenSsl' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.SafeEvpPKeyHandle' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Security.Permissions:
-MembersMustExist : Member 'System.Security.Permissions.KeyContainerPermissionAccessEntryCollection..ctor()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Permissions.KeyContainerPermissionAccessEntryCollection.CopyTo(System.Array, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Permissions.KeyContainerPermissionAccessEntryEnumerator..ctor()' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.Security.Principal.Windows:
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinAccountReadonlyControllersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinApplicationPackageAuthoritySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinAnyPackageSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinCertSvcDComAccessGroup' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinCryptoOperatorsSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinDCOMUsersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinEventLogReadersGroup' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinBuiltinIUsersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCacheablePrincipalsGroupSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityDocumentsLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityEnterpriseAuthenticationSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityInternetClientServerSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityInternetClientSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityMusicLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityPicturesLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityPrivateNetworkClientServerSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityRemovableStorageSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilitySharedUserCertificatesSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCapabilityVideosLibrarySid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinConsoleLogonSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinCreatorOwnerRightsSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinEnterpriseReadonlyControllersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinHighLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinIUserSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinLocalLogonSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinLowLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinMediumLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinMediumPlusLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinNewEnterpriseReadonlyControllersSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinNonCacheablePrincipalsGroupSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinSystemLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinThisOrganizationCertificateSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinUntrustedLabelSid' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Principal.WellKnownSidType System.Security.Principal.WellKnownSidType.WinWriteRestrictedCodeSid' does not exist in the implementation but it does exist in the contract.
-Compat issues with assembly System.ServiceProcess.ServiceController:
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.ServiceProcess.SessionChangeDescription' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.ServiceProcess.SessionChangeDescription' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-Total Issues: 92
diff --git a/src/libraries/shims/ApiCompatBaseline.netfx.netstandardOnly.txt b/src/libraries/shims/ApiCompatBaseline.netfx.netstandardOnly.txt
deleted file mode 100644
index f68769e14f0810..00000000000000
--- a/src/libraries/shims/ApiCompatBaseline.netfx.netstandardOnly.txt
+++ /dev/null
@@ -1,870 +0,0 @@
-Compat issues with assembly netstandard:
-MembersMustExist : Member 'System.Array.Fill<T>(T[], T)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Array.Fill<T>(T[], T, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Array.Reverse<T>(T[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Array.Reverse<T>(T[], System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.ArraySegment<T>' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.ArraySegment<T>' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.ArraySegment<T>.CopyTo(System.ArraySegment<T>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.CopyTo(T[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.CopyTo(T[], System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.Empty.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.GetEnumerator()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.Item.get(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.Item.set(System.Int32, T)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.op_Implicit(T[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.Slice(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.Slice(System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ArraySegment<T>.ToArray()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ArraySegment<T>.Enumerator' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.Int32BitsToSingle(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.SingleToInt32Bits(System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToBoolean(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToChar(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToDouble(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToInt16(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToInt32(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToInt64(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToSingle(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToUInt16(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToUInt32(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.ToUInt64(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.Char)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.Int16)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.Int64)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.UInt16)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.UInt32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.BitConverter.TryWriteBytes(System.Span<System.Byte>, System.UInt64)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Boolean' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Boolean' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Boolean.Parse(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Boolean.TryFormat(System.Span<System.Char>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Boolean.TryParse(System.ReadOnlySpan<System.Char>, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Byte' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Byte' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Byte.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Byte.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Byte.TryParse(System.ReadOnlySpan<System.Char>, System.Byte)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Byte.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Byte)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Char' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Char' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.ConsoleKeyInfo' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.ConsoleKeyInfo' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Convert.ToBase64String(System.ReadOnlySpan<System.Byte>, System.Base64FormattingOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Convert.TryFromBase64Chars(System.ReadOnlySpan<System.Char>, System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Convert.TryFromBase64String(System.String, System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Convert.TryToBase64Chars(System.ReadOnlySpan<System.Byte>, System.Span<System.Char>, System.Int32, System.Base64FormattingOptions)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.DateTime' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.DateTime' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.DateTime System.DateTime.UnixEpoch' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.Parse(System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.ParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.ParseExact(System.ReadOnlySpan<System.Char>, System.String[], System.IFormatProvider, System.Globalization.DateTimeStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.TryParse(System.ReadOnlySpan<System.Char>, System.DateTime)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.TryParse(System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles, System.DateTime)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.TryParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles, System.DateTime)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTime.TryParseExact(System.ReadOnlySpan<System.Char>, System.String[], System.IFormatProvider, System.Globalization.DateTimeStyles, System.DateTime)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.DateTimeOffset' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.DateTimeOffset' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.DateTimeOffset System.DateTimeOffset.UnixEpoch' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.Parse(System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.ParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.ParseExact(System.ReadOnlySpan<System.Char>, System.String[], System.IFormatProvider, System.Globalization.DateTimeStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.TryParse(System.ReadOnlySpan<System.Char>, System.DateTimeOffset)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.TryParse(System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles, System.DateTimeOffset)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.TryParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.DateTimeStyles, System.DateTimeOffset)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.DateTimeOffset.TryParseExact(System.ReadOnlySpan<System.Char>, System.String[], System.IFormatProvider, System.Globalization.DateTimeStyles, System.DateTimeOffset)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Decimal' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Decimal' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Decimal.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Decimal.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Decimal.TryParse(System.ReadOnlySpan<System.Char>, System.Decimal)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Decimal.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Decimal)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Double' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Double' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Double.IsFinite(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Double.IsNegative(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Double.IsNormal(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Double.IsSubnormal(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Double.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Double.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Double.TryParse(System.ReadOnlySpan<System.Char>, System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Double.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Enum.Parse<TEnum>(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Enum.Parse<TEnum>(System.String, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Enum.TryParse(System.Type, System.String, System.Boolean, System.Object)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Enum.TryParse(System.Type, System.String, System.Object)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.GC.GetAllocatedBytesForCurrentThread()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Guid..ctor(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Guid.Parse(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Guid.ParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Guid.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Guid.TryParse(System.ReadOnlySpan<System.Char>, System.Guid)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Guid.TryParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.Guid)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Guid.TryWriteBytes(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.HashCode' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IAsyncDisposable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Index' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Int16' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Int16' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Int16.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int16.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int16.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Int16)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int16.TryParse(System.ReadOnlySpan<System.Char>, System.Int16)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Int32' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Int32' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Int32.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int32.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int32.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int32.TryParse(System.ReadOnlySpan<System.Char>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Int64' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Int64' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Int64.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int64.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int64.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Int64)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Int64.TryParse(System.ReadOnlySpan<System.Char>, System.Int64)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.IntPtr' in the contract but not the implementation.
-CannotRemoveBaseTypeOrInterface : Type 'System.IntPtr' does not implement interface 'System.IEquatable<System.IntPtr>' in the implementation but it does in the contract.
-TypeCannotChangeClassification : Type 'System.IntPtr' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Lazy<T>..ctor(T)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Acosh(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Asinh(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Atanh(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Cbrt(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.Byte, System.Byte, System.Byte)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.Decimal, System.Decimal, System.Decimal)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.Double, System.Double, System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.Int16, System.Int16, System.Int16)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.Int32, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.Int64, System.Int64, System.Int64)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.SByte, System.SByte, System.SByte)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.Single, System.Single, System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.UInt16, System.UInt16, System.UInt16)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.UInt32, System.UInt32, System.UInt32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Math.Clamp(System.UInt64, System.UInt64, System.UInt64)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.MathF' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Memory<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.MemoryExtensions' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Random.NextBytes(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Range' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ReadOnlyMemory<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.ReadOnlySpan<T>' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsByRefLikeAttribute' exists on 'System.RuntimeArgumentHandle' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.RuntimeArgumentHandle' is a 'struct' in the implementation but is a 'ref struct' in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.SByte' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.SByte' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.SByte.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.SByte.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.SByte.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.SByte)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.SByte.TryParse(System.ReadOnlySpan<System.Char>, System.SByte)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.SequencePosition' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Single' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Single' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Single.IsFinite(System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Single.IsNegative(System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Single.IsNormal(System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Single.IsSubnormal(System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Single.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Single.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Single.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Single.TryParse(System.ReadOnlySpan<System.Char>, System.Single)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Span<T>' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String..ctor(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Chars.get(System.Index)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Chars.get(System.Range)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Contains(System.Char)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Contains(System.Char, System.StringComparison)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Contains(System.String, System.StringComparison)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Create<TState>(System.Int32, TState, System.Buffers.SpanAction<System.Char, TState>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.EndsWith(System.Char)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.GetHashCode(System.StringComparison)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.IndexOf(System.Char, System.StringComparison)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Join(System.Char, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Join(System.Char, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Join(System.Char, System.String[], System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Join<T>(System.Char, System.Collections.Generic.IEnumerable<T>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.op_Implicit(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Replace(System.String, System.String, System.Boolean, System.Globalization.CultureInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Replace(System.String, System.String, System.StringComparison)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Split(System.Char, System.Int32, System.StringSplitOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Split(System.Char, System.StringSplitOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Split(System.String, System.Int32, System.StringSplitOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Split(System.String, System.StringSplitOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.StartsWith(System.Char)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Substring(System.Index)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Substring(System.Range)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.Trim(System.Char)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.TrimEnd()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.TrimEnd(System.Char)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.TrimStart()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String.TrimStart(System.Char)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.StringComparer.Create(System.Globalization.CultureInfo, System.Globalization.CompareOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.StringComparer.FromComparison(System.StringComparison)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.TimeSpan' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.TimeSpan' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.TimeSpan.Divide(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.Divide(System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.Multiply(System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.op_Division(System.TimeSpan, System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.op_Division(System.TimeSpan, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.op_Multiply(System.Double, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.op_Multiply(System.TimeSpan, System.Double)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.Parse(System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.ParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.TimeSpanStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.ParseExact(System.ReadOnlySpan<System.Char>, System.String[], System.IFormatProvider, System.Globalization.TimeSpanStyles)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.TryParse(System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.TryParse(System.ReadOnlySpan<System.Char>, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.TryParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.Globalization.TimeSpanStyles, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.TryParseExact(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.IFormatProvider, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.TryParseExact(System.ReadOnlySpan<System.Char>, System.String[], System.IFormatProvider, System.Globalization.TimeSpanStyles, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.TimeSpan.TryParseExact(System.ReadOnlySpan<System.Char>, System.String[], System.IFormatProvider, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.TimeZoneInfo.TransitionTime' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.TimeZoneInfo.TransitionTime' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Type.GetMethod(System.String, System.Int32, System.Reflection.BindingFlags, System.Reflection.Binder, System.Reflection.CallingConventions, System.Type[], System.Reflection.ParameterModifier[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.GetMethod(System.String, System.Int32, System.Reflection.BindingFlags, System.Reflection.Binder, System.Type[], System.Reflection.ParameterModifier[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.GetMethod(System.String, System.Int32, System.Type[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.GetMethod(System.String, System.Int32, System.Type[], System.Reflection.ParameterModifier[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.GetMethodImpl(System.String, System.Int32, System.Reflection.BindingFlags, System.Reflection.Binder, System.Reflection.CallingConventions, System.Type[], System.Reflection.ParameterModifier[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.IsByRefLike.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.IsGenericMethodParameter.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.IsGenericTypeParameter.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.IsSignatureType.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.IsSZArray.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.IsTypeDefinition.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.IsVariableBoundArray.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Type.MakeGenericMethodParameter(System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsByRefLikeAttribute' exists on 'System.TypedReference' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.TypedReference' is a 'struct' in the implementation but is a 'ref struct' in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.UInt16' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.UInt16' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.UInt16.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt16.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt16.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.UInt16)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt16.TryParse(System.ReadOnlySpan<System.Char>, System.UInt16)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.UInt32' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.UInt32' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.UInt32.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt32.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt32.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.UInt32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt32.TryParse(System.ReadOnlySpan<System.Char>, System.UInt32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.UInt64' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.UInt64' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.UInt64.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt64.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt64.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.UInt64)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.UInt64.TryParse(System.ReadOnlySpan<System.Char>, System.UInt64)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.UIntPtr' in the contract but not the implementation.
-CannotRemoveBaseTypeOrInterface : Type 'System.UIntPtr' does not implement interface 'System.IEquatable<System.UIntPtr>' in the implementation but it does in the contract.
-TypeCannotChangeClassification : Type 'System.UIntPtr' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Version.Parse(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Version.TryFormat(System.Span<System.Char>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Version.TryFormat(System.Span<System.Char>, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Version.TryParse(System.ReadOnlySpan<System.Char>, System.Version)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.ArrayPool<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.BuffersExtensions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.IBufferWriter<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.IMemoryOwner<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.IPinnable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.MemoryHandle' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.MemoryManager<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.MemoryPool<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.OperationStatus' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.ReadOnlySequence<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.ReadOnlySequenceSegment<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.ReadOnlySpanAction<T, TArg>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.SpanAction<T, TArg>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.StandardFormat' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.Binary.BinaryPrimitives' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.Text.Base64' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.Text.Utf8Formatter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Buffers.Text.Utf8Parser' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.CodeDom.Compiler.IndentedTextWriter' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Collections.BitArray.LeftShift(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.BitArray.RightShift(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.DictionaryEntry.Deconstruct(System.Object, System.Object)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Concurrent.ConcurrentBag<T>.Clear()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Concurrent.ConcurrentQueue<T>.Clear()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Collections.Generic.CollectionExtensions' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Dictionary<TKey, TValue>..ctor(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Dictionary<TKey, TValue>..ctor(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IEqualityComparer<TKey>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Dictionary<TKey, TValue>.EnsureCapacity(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Dictionary<TKey, TValue>.Remove(TKey, TValue)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Dictionary<TKey, TValue>.TrimExcess()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Dictionary<TKey, TValue>.TrimExcess(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Dictionary<TKey, TValue>.TryAdd(TKey, TValue)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.HashSet<T>.EnsureCapacity(System.Int32)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Collections.Generic.IAsyncEnumerable<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Collections.Generic.IAsyncEnumerator<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Collections.Generic.KeyValuePair' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Collections.Generic.KeyValuePair<TKey, TValue>' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Collections.Generic.KeyValuePair<TKey, TValue>' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Collections.Generic.KeyValuePair<TKey, TValue>.Deconstruct(TKey, TValue)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Queue<T>.TryDequeue(T)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Queue<T>.TryPeek(T)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Stack<T>.TryPeek(T)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.Generic.Stack<T>.TryPop(T)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Collections.ObjectModel.KeyedCollection<TKey, TItem>.TryGetValue(TKey, TItem)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Collections.Specialized.BitVector32.Section' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Collections.Specialized.BitVector32.Section' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.ComponentModel.DefaultValueAttribute..ctor(System.SByte)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DefaultValueAttribute..ctor(System.UInt16)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DefaultValueAttribute..ctor(System.UInt32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.ComponentModel.DefaultValueAttribute..ctor(System.UInt64)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.ComponentModel.Design.Serialization.MemberRelationship' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.ComponentModel.Design.Serialization.MemberRelationship' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-TypesMustExist : Type 'System.Data.Common.DbProviderFactories' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Diagnostics.ProcessStartInfo.ArgumentList.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Diagnostics.ProcessStartInfo.StandardInputEncoding.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Diagnostics.ProcessStartInfo.StandardInputEncoding.set(System.Text.Encoding)' does not exist in the implementation but it does exist in the contract.
-CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute' changed from '[AttributeUsageAttribute(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Event | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Struct, Inherited=false, AllowMultiple=false)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Event | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Struct, Inherited=false, AllowMultiple=false)]' in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Diagnostics.SymbolStore.SymbolToken' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Diagnostics.SymbolStore.SymbolToken' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveBaseTypeOrInterface : Type 'System.Diagnostics.Tracing.EventCounter' does not implement interface 'System.IDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Diagnostics.Tracing.EventCounter.Dispose()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Diagnostics.Tracing.EventSourceCreatedEventArgs' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Drawing.Color' in the contract but not the implementation.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.Color' does not implement interface 'System.IEquatable<System.Drawing.Color>' in the implementation but it does in the contract.
-TypeCannotChangeClassification : Type 'System.Drawing.Color' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Drawing.Color.Equals(System.Drawing.Color)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.ColorConverter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.KnownColor' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.Point' does not implement interface 'System.IEquatable<System.Drawing.Point>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Drawing.Point.Equals(System.Drawing.Point)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.PointConverter' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.PointF' does not implement interface 'System.IEquatable<System.Drawing.PointF>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Drawing.PointF.Equals(System.Drawing.PointF)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.Rectangle' does not implement interface 'System.IEquatable<System.Drawing.Rectangle>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Drawing.Rectangle.Equals(System.Drawing.Rectangle)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.RectangleConverter' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.RectangleF' does not implement interface 'System.IEquatable<System.Drawing.RectangleF>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Drawing.RectangleF.Equals(System.Drawing.RectangleF)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.Size' does not implement interface 'System.IEquatable<System.Drawing.Size>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Drawing.Size.Equals(System.Drawing.Size)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.Size.op_Division(System.Drawing.Size, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.Size.op_Division(System.Drawing.Size, System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.Size.op_Multiply(System.Drawing.Size, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.Size.op_Multiply(System.Drawing.Size, System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.Size.op_Multiply(System.Int32, System.Drawing.Size)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.Size.op_Multiply(System.Single, System.Drawing.Size)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.SizeConverter' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Drawing.SizeF' does not implement interface 'System.IEquatable<System.Drawing.SizeF>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Drawing.SizeF.Equals(System.Drawing.SizeF)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.SizeF.op_Division(System.Drawing.SizeF, System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.SizeF.op_Multiply(System.Drawing.SizeF, System.Single)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Drawing.SizeF.op_Multiply(System.Single, System.Drawing.SizeF)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Drawing.SizeFConverter' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Globalization.CharUnicodeInfo.GetUnicodeCategory(System.Int32)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Globalization.ISOWeek' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.BinaryReader.Read(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.BinaryReader.Read(System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.BinaryWriter' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.BinaryWriter.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.BinaryWriter.Write(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.BinaryWriter.Write(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.BufferedStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.BufferedStream.BufferSize.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.BufferedStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.BufferedStream.UnderlyingStream.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.EnumerateDirectories(System.String, System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.EnumerateFiles(System.String, System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.EnumerateFileSystemEntries(System.String, System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.GetDirectories(System.String, System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.GetFiles(System.String, System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Directory.GetFileSystemEntries(System.String, System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.EnumerateDirectories(System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.EnumerateFiles(System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.EnumerateFileSystemInfos(System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.GetDirectories(System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.GetFiles(System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.DirectoryInfo.GetFileSystemInfos(System.String, System.IO.EnumerationOptions)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.EnumerationOptions' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.AppendAllLinesAsync(System.String, System.Collections.Generic.IEnumerable<System.String>, System.Text.Encoding, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.AppendAllLinesAsync(System.String, System.Collections.Generic.IEnumerable<System.String>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.AppendAllTextAsync(System.String, System.String, System.Text.Encoding, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.AppendAllTextAsync(System.String, System.String, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.ReadAllBytesAsync(System.String, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.ReadAllLinesAsync(System.String, System.Text.Encoding, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.ReadAllLinesAsync(System.String, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.ReadAllTextAsync(System.String, System.Text.Encoding, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.ReadAllTextAsync(System.String, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.WriteAllBytesAsync(System.String, System.Byte[], System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.WriteAllLinesAsync(System.String, System.Collections.Generic.IEnumerable<System.String>, System.Text.Encoding, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.WriteAllLinesAsync(System.String, System.Collections.Generic.IEnumerable<System.String>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.WriteAllTextAsync(System.String, System.String, System.Text.Encoding, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.File.WriteAllTextAsync(System.String, System.String, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.FileStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-CannotMakeMemberNonVirtual : Member 'System.IO.FileStream.Name' is non-virtual in the implementation but is virtual in the contract.
-MembersMustExist : Member 'System.IO.FileStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-CannotMakeMemberNonVirtual : Member 'System.IO.FileStream.Name.get()' is non-virtual in the implementation but is virtual in the contract.
-TypesMustExist : Type 'System.IO.MatchCasing' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.MatchType' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.MemoryStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.MemoryStream.Read(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.MemoryStream.ReadAsync(System.Memory<System.Byte>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.MemoryStream.Write(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.MemoryStream.WriteAsync(System.ReadOnlyMemory<System.Byte>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.GetDirectoryName(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.GetExtension(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.GetFileName(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.GetFileNameWithoutExtension(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.GetFullPath(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.GetPathRoot(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.GetRelativePath(System.String, System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.HasExtension(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.IsPathFullyQualified(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.IsPathFullyQualified(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.IsPathRooted(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.Join(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.Join(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.TryJoin(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.Span<System.Char>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Path.TryJoin(System.ReadOnlySpan<System.Char>, System.ReadOnlySpan<System.Char>, System.Span<System.Char>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Stream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-CannotMakeMemberNonVirtual : Member 'System.IO.Stream.CopyTo(System.IO.Stream, System.Int32)' is non-virtual in the implementation but is virtual in the contract.
-MembersMustExist : Member 'System.IO.Stream.CopyToAsync(System.IO.Stream, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Stream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Stream.Read(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Stream.ReadAsync(System.Memory<System.Byte>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Stream.Write(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Stream.WriteAsync(System.ReadOnlyMemory<System.Byte>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamReader.Read(System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamReader.ReadAsync(System.Memory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamReader.ReadBlock(System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamReader.ReadBlockAsync(System.Memory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.StreamWriter' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.StreamWriter.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamWriter.Write(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamWriter.WriteAsync(System.ReadOnlyMemory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamWriter.WriteLine(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StreamWriter.WriteLineAsync(System.ReadOnlyMemory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StringReader.Read(System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StringReader.ReadAsync(System.Memory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StringReader.ReadBlock(System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StringReader.ReadBlockAsync(System.Memory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.StringWriter' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.StringWriter.Write(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StringWriter.WriteAsync(System.ReadOnlyMemory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StringWriter.WriteLine(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.StringWriter.WriteLineAsync(System.ReadOnlyMemory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextReader.Read(System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextReader.ReadAsync(System.Memory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextReader.ReadBlock(System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextReader.ReadBlockAsync(System.Memory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.TextWriter' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.TextWriter.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextWriter.Write(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextWriter.WriteAsync(System.ReadOnlyMemory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextWriter.WriteLine(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.TextWriter.WriteLineAsync(System.ReadOnlyMemory<System.Char>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.UnmanagedMemoryStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.UnmanagedMemoryStream.Read(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.UnmanagedMemoryStream.Write(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Compression.BrotliDecoder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Compression.BrotliEncoder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Compression.BrotliStream' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Compression.DeflateStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.Compression.DeflateStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Compression.GZipStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.Compression.GZipStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Compression.ZipArchiveEntry.Crc32.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Compression.ZipFile.ExtractToDirectory(System.String, System.String, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Compression.ZipFile.ExtractToDirectory(System.String, System.String, System.Text.Encoding, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.IO.Compression.ZipFileExtensions.ExtractToDirectory(System.IO.Compression.ZipArchive, System.String, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Enumeration.FileSystemEntry' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Enumeration.FileSystemEnumerable<TResult>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Enumeration.FileSystemEnumerator<TResult>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.IO.Enumeration.FileSystemName' does not exist in the implementation but it does exist in the contract.
-CannotAddAbstractMembers : Member 'System.IO.IsolatedStorage.IsolatedStorage.GetPermission(System.Security.PermissionSet)' is abstract in the implementation but is missing in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.IsolatedStorage.IsolatedStorageFileStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.IsolatedStorage.IsolatedStorageFileStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.MemoryMappedFiles.MemoryMappedViewStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Pipes.AnonymousPipeClientStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Pipes.AnonymousPipeServerStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Pipes.NamedPipeClientStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Pipes.NamedPipeServerStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.IO.Pipes.PipeOptions System.IO.Pipes.PipeOptions.CurrentUserOnly' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.IO.Pipes.PipeStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Linq.Enumerable.SkipLast<TSource>(System.Collections.Generic.IEnumerable<TSource>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Linq.Enumerable.TakeLast<TSource>(System.Collections.Generic.IEnumerable<TSource>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Linq.Queryable.Append<TSource>(System.Linq.IQueryable<TSource>, TSource)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Linq.Queryable.Prepend<TSource>(System.Linq.IQueryable<TSource>, TSource)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Linq.Queryable.SkipLast<TSource>(System.Linq.IQueryable<TSource>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Linq.Queryable.TakeLast<TSource>(System.Linq.IQueryable<TSource>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.AlreadyReported' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.EarlyHints' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.FailedDependency' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.IMUsed' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.InsufficientStorage' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.Locked' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.LoopDetected' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.MisdirectedRequest' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.MultiStatus' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.NetworkAuthenticationRequired' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.NotExtended' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.PermanentRedirect' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.PreconditionRequired' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.Processing' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.RequestHeaderFieldsTooLarge' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.TooManyRequests' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.UnavailableForLegalReasons' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.UnprocessableEntity' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.HttpStatusCode System.Net.HttpStatusCode.VariantAlsoNegotiates' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Version System.Net.HttpVersion.Unknown' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Version System.Net.HttpVersion.Version20' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.IPAddress..ctor(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.IPAddress..ctor(System.ReadOnlySpan<System.Byte>, System.Int64)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.IPAddress.Parse(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.IPAddress.TryFormat(System.Span<System.Char>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.IPAddress.TryParse(System.ReadOnlySpan<System.Char>, System.Net.IPAddress)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.IPAddress.TryWriteBytes(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Http.HttpClient.PatchAsync(System.String, System.Net.Http.HttpContent)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Http.HttpClient.PatchAsync(System.String, System.Net.Http.HttpContent, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Http.HttpClient.PatchAsync(System.Uri, System.Net.Http.HttpContent)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Http.HttpClient.PatchAsync(System.Uri, System.Net.Http.HttpContent, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Http.HttpMethod.Patch.get()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Http.ReadOnlyMemoryContent' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String System.Net.Mime.MediaTypeNames.Application.Json' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.String System.Net.Mime.MediaTypeNames.Application.Xml' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Security.AuthenticatedStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Net.Security.AuthenticatedStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Security.NegotiateStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Net.Security.NegotiateStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Security.ServerCertificateSelectionCallback' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Security.SslApplicationProtocol' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Security.SslClientAuthenticationOptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Security.SslServerAuthenticationOptions' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Security.SslStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Net.Security.SslStream.AuthenticateAsClientAsync(System.Net.Security.SslClientAuthenticationOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Security.SslStream.AuthenticateAsServerAsync(System.Net.Security.SslServerAuthenticationOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Security.SslStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Security.SslStream.NegotiatedApplicationProtocol.get()' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Net.Sockets.NetworkStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Net.Sockets.Socket.Receive(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.Socket.Receive(System.Span<System.Byte>, System.Net.Sockets.SocketFlags)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.Socket.Receive(System.Span<System.Byte>, System.Net.Sockets.SocketFlags, System.Net.Sockets.SocketError)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.Socket.Send(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.Socket.Send(System.ReadOnlySpan<System.Byte>, System.Net.Sockets.SocketFlags)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.Socket.Send(System.ReadOnlySpan<System.Byte>, System.Net.Sockets.SocketFlags, System.Net.Sockets.SocketError)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.SocketAsyncEventArgs.MemoryBuffer.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.SocketAsyncEventArgs.SetBuffer(System.Memory<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.SocketTaskExtensions.ReceiveAsync(System.Net.Sockets.Socket, System.Memory<System.Byte>, System.Net.Sockets.SocketFlags, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.Sockets.SocketTaskExtensions.SendAsync(System.Net.Sockets.Socket, System.ReadOnlyMemory<System.Byte>, System.Net.Sockets.SocketFlags, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.Sockets.UnixDomainSocketEndPoint' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.WebSockets.ClientWebSocketOptions.RemoteCertificateValidationCallback.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.WebSockets.ClientWebSocketOptions.RemoteCertificateValidationCallback.set(System.Net.Security.RemoteCertificateValidationCallback)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Net.WebSockets.ValueWebSocketReceiveResult' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.WebSockets.WebSocket.CreateFromStream(System.IO.Stream, System.Boolean, System.String, System.TimeSpan)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.WebSockets.WebSocket.ReceiveAsync(System.Memory<System.Byte>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Net.WebSockets.WebSocket.SendAsync(System.ReadOnlyMemory<System.Byte>, System.Net.WebSockets.WebSocketMessageType, System.Boolean, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Numerics.BigInteger' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Numerics.BigInteger' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Numerics.BigInteger..ctor(System.ReadOnlySpan<System.Byte>, System.Boolean, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Numerics.BigInteger.GetByteCount(System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Numerics.BigInteger.Parse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Numerics.BigInteger.ToByteArray(System.Boolean, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Numerics.BigInteger.TryFormat(System.Span<System.Char>, System.Int32, System.ReadOnlySpan<System.Char>, System.IFormatProvider)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Numerics.BigInteger.TryParse(System.ReadOnlySpan<System.Char>, System.Globalization.NumberStyles, System.IFormatProvider, System.Numerics.BigInteger)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Numerics.BigInteger.TryParse(System.ReadOnlySpan<System.Char>, System.Numerics.BigInteger)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Numerics.BigInteger.TryWriteBytes(System.Span<System.Byte>, System.Int32, System.Boolean, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Matrix3x2' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Matrix4x4' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Plane' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Quaternion' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Vector' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Vector<T>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Vector2' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Vector3' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Numerics.Vector4' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.Assembly.GetForwardedTypes()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.BindingFlags System.Reflection.BindingFlags.DoNotWrapExceptions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.DispatchProxy' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.MemberInfo.HasSameMetadataDefinitionAs(System.Reflection.MemberInfo)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.MethodBase.IsConstructedGenericMethod.get()' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Reflection.ParameterModifier' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Reflection.ParameterModifier' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Reflection.TypeDelegator.IsByRefLike.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.TypeDelegator.IsGenericMethodParameter.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.TypeDelegator.IsGenericTypeParameter.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.TypeDelegator.IsSZArray.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.TypeDelegator.IsTypeDefinition.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Reflection.TypeDelegator.IsVariableBoundArray.get()' does not exist in the implementation but it does exist in the contract.
-CannotSealType : Type 'System.Reflection.TypeInfo' is effectively (has a private constructor) sealed in the implementation but not sealed in the contract.
-MembersMustExist : Member 'System.Reflection.TypeInfo..ctor()' does not exist in the implementation but it does exist in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredConstructors' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredEvents' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredFields' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredMembers' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredMethods' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredNestedTypes' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredProperties' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GenericTypeParameters' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.ImplementedInterfaces' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.AsType()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredConstructors.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredEvents.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredFields.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredMembers.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredMethods.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredNestedTypes.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.DeclaredProperties.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GenericTypeParameters.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GetDeclaredEvent(System.String)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GetDeclaredField(System.String)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GetDeclaredMethod(System.String)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GetDeclaredMethods(System.String)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GetDeclaredNestedType(System.String)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.GetDeclaredProperty(System.String)' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.ImplementedInterfaces.get()' is non-virtual in the implementation but is virtual in the contract.
-CannotMakeMemberNonVirtual : Member 'System.Reflection.TypeInfo.IsAssignableFrom(System.Reflection.TypeInfo)' is non-virtual in the implementation but is virtual in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.AssemblyBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.AssemblyBuilderAccess' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.ConstructorBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.CustomAttributeBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.DynamicILInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.DynamicMethod' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.EnumBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.EventBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.EventToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.ExceptionHandler' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.FieldBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.FieldToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.GenericTypeParameterBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.ILGenerator' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.Label' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.LocalBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.MethodBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.MethodToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.ModuleBuilder' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Reflection.Emit.OpCode' in the contract but not the implementation.
-CannotRemoveBaseTypeOrInterface : Type 'System.Reflection.Emit.OpCode' does not implement interface 'System.IEquatable<System.Reflection.Emit.OpCode>' in the implementation but it does in the contract.
-TypeCannotChangeClassification : Type 'System.Reflection.Emit.OpCode' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-TypesMustExist : Type 'System.Reflection.Emit.ParameterBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.ParameterToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.PropertyBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.PropertyToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.SignatureHelper' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.SignatureToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.StringToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.TypeBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Reflection.Emit.TypeToken' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.AsyncIteratorMethodBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.AsyncMethodBuilderAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder<TResult>' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Runtime.CompilerServices.ConditionalWeakTable<TKey, TValue>' does not implement interface 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Runtime.CompilerServices.ConditionalWeakTable<TKey, TValue>.AddOrUpdate(TKey, TValue)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.CompilerServices.ConditionalWeakTable<TKey, TValue>.Clear()' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ConfiguredAsyncDisposable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<T>' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable<TResult>' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable<TResult>' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable<TResult>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.IsByRefLikeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.IsReadOnlyAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ITuple' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.RuntimeFeature' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.CompilerServices.RuntimeHelpers.GetSubArray<T>(T[], System.Range)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(System.Type)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.CompilerServices.RuntimeHelpers.IsReferenceOrContainsReferences<T>()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.CompilerServices.RuntimeHelpers.TryEnsureSufficientExecutionStack()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.CompilerServices.RuntimeWrappedException..ctor(System.Object)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.SwitchExpressionException' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.TaskAwaiter' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.TaskAwaiter' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.TaskAwaiter<TResult>' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.TaskAwaiter<TResult>' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ValueTaskAwaiter' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.CompilerServices.ValueTaskAwaiter<TResult>' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.YieldAwaitable' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.YieldAwaitable' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw(System.Exception)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.AutomationProxyAttribute' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.InteropServices.HandleRef' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.InteropServices.HandleRef' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-TypesMustExist : Type 'System.Runtime.InteropServices.ImportedFromTypeLibAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.ManagedToNativeComInteropStubAttribute' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.PtrToStringUTF8(System.IntPtr)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.PtrToStringUTF8(System.IntPtr, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.StringToCoTaskMemUTF8(System.String)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Runtime.InteropServices.Marshal.ZeroFreeCoTaskMemUTF8(System.IntPtr)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.MemoryMarshal' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.InteropServices.OSPlatform' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.InteropServices.OSPlatform' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-TypesMustExist : Type 'System.Runtime.InteropServices.SequenceMarshal' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibFuncAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibFuncFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibImportClassAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibTypeAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibTypeFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibVarAttribute' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibVarFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Runtime.InteropServices.TypeLibVersionAttribute' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.Serialization.SerializationEntry' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.Serialization.SerializationEntry' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Runtime.Serialization.StreamingContext' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Runtime.Serialization.StreamingContext' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-TypesMustExist : Type 'System.Runtime.Serialization.Formatters.IFieldInfo' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.CryptographicOperations' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Security.Cryptography.CryptoStream' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.CryptoStream.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.DSA.TryCreateSignature(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.DSA.TryHashData(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.DSA.TrySignData(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.DSA.VerifyData(System.ReadOnlySpan<System.Byte>, System.ReadOnlySpan<System.Byte>, System.Security.Cryptography.HashAlgorithmName)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.DSA.VerifySignature(System.ReadOnlySpan<System.Byte>, System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.ECDiffieHellman' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.ECDsa.TryHashData(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.ECDsa.TrySignData(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.ECDsa.TrySignHash(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.ECDsa.VerifyData(System.ReadOnlySpan<System.Byte>, System.ReadOnlySpan<System.Byte>, System.Security.Cryptography.HashAlgorithmName)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.ECDsa.VerifyHash(System.ReadOnlySpan<System.Byte>, System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HashAlgorithm.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HashAlgorithm.TryComputeHash(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HashAlgorithm.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Security.Cryptography.HashAlgorithmName' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Security.Cryptography.HashAlgorithmName' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Security.Cryptography.HMAC.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMAC.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACMD5.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACMD5.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA1.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA1.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA256.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA256.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA384.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA384.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA512.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.HMACSHA512.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.IncrementalHash.AppendData(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.IncrementalHash.TryGetHashAndReset(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RandomNumberGenerator.Fill(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RandomNumberGenerator.GetBytes(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RandomNumberGenerator.GetInt32(System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RandomNumberGenerator.GetInt32(System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RandomNumberGenerator.GetNonZeroBytes(System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.Rfc2898DeriveBytes.HashAlgorithm.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RSA.TryDecrypt(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.RSAEncryptionPadding, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RSA.TryEncrypt(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.RSAEncryptionPadding, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RSA.TryHashData(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RSA.TrySignData(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Security.Cryptography.RSASignaturePadding, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RSA.TrySignHash(System.ReadOnlySpan<System.Byte>, System.Span<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Security.Cryptography.RSASignaturePadding, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RSA.VerifyData(System.ReadOnlySpan<System.Byte>, System.ReadOnlySpan<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Security.Cryptography.RSASignaturePadding)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.RSA.VerifyHash(System.ReadOnlySpan<System.Byte>, System.ReadOnlySpan<System.Byte>, System.Security.Cryptography.HashAlgorithmName, System.Security.Cryptography.RSASignaturePadding)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA1Managed.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA1Managed.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA256Managed.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA256Managed.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA384Managed.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA384Managed.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA512Managed.HashCore(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.SHA512Managed.TryHashFinal(System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.CertificateRequest' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.DSACertificateExtensions' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.SubjectAlternativeNameBuilder' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.X509Certificates.X509Certificate.GetCertHash(System.Security.Cryptography.HashAlgorithmName)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.X509Certificates.X509Certificate.GetCertHashString(System.Security.Cryptography.HashAlgorithmName)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.X509Certificates.X509Certificate.TryGetCertHash(System.Security.Cryptography.HashAlgorithmName, System.Span<System.Byte>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Security.Cryptography.X509Certificates.X509SignatureGenerator' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.X509Certificates.X509Store..ctor(System.Security.Cryptography.X509Certificates.StoreName, System.Security.Cryptography.X509Certificates.StoreLocation, System.Security.Cryptography.X509Certificates.OpenFlags)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.X509Certificates.X509Store..ctor(System.String, System.Security.Cryptography.X509Certificates.StoreLocation, System.Security.Cryptography.X509Certificates.OpenFlags)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Security.Cryptography.X509Certificates.X509Store.IsOpen.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Decoder.Convert(System.ReadOnlySpan<System.Byte>, System.Span<System.Char>, System.Boolean, System.Int32, System.Int32, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Decoder.GetCharCount(System.ReadOnlySpan<System.Byte>, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Decoder.GetChars(System.ReadOnlySpan<System.Byte>, System.Span<System.Char>, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoder.Convert(System.ReadOnlySpan<System.Char>, System.Span<System.Byte>, System.Boolean, System.Int32, System.Int32, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoder.GetByteCount(System.ReadOnlySpan<System.Char>, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoder.GetBytes(System.ReadOnlySpan<System.Char>, System.Span<System.Byte>, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.GetByteCount(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.GetByteCount(System.String, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.GetBytes(System.ReadOnlySpan<System.Char>, System.Span<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.GetBytes(System.String, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.GetCharCount(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.GetChars(System.ReadOnlySpan<System.Byte>, System.Span<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.GetString(System.ReadOnlySpan<System.Byte>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.Encoding.Preamble.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.Append(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.Append(System.Text.StringBuilder)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.Append(System.Text.StringBuilder, System.Int32, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.AppendJoin(System.Char, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.AppendJoin(System.Char, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.AppendJoin(System.String, System.Object[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.AppendJoin(System.String, System.String[])' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.AppendJoin<T>(System.Char, System.Collections.Generic.IEnumerable<T>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.AppendJoin<T>(System.String, System.Collections.Generic.IEnumerable<T>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.CopyTo(System.Int32, System.Span<System.Char>, System.Int32)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.Equals(System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Text.StringBuilder.Insert(System.Int32, System.ReadOnlySpan<System.Char>)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Text.RegularExpressions.CaptureCollection' does not implement interface 'System.Collections.Generic.ICollection<System.Text.RegularExpressions.Capture>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Text.RegularExpressions.CaptureCollection.CopyTo(System.Text.RegularExpressions.Capture[], System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Text.RegularExpressions.GroupCollection' does not implement interface 'System.Collections.Generic.ICollection<System.Text.RegularExpressions.Group>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Text.RegularExpressions.GroupCollection.CopyTo(System.Text.RegularExpressions.Group[], System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Text.RegularExpressions.MatchCollection' does not implement interface 'System.Collections.Generic.ICollection<System.Text.RegularExpressions.Match>' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Text.RegularExpressions.MatchCollection.CopyTo(System.Text.RegularExpressions.Match[], System.Int32)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Threading.AsyncLocalValueChangedArgs<T>' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Threading.AsyncLocalValueChangedArgs<T>' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Threading.CancellationToken' in the contract but not the implementation.
-TypeCannotChangeClassification : Type 'System.Threading.CancellationToken' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.IsReadOnlyAttribute' exists on 'System.Threading.CancellationTokenRegistration' in the contract but not the implementation.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.CancellationTokenRegistration' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-TypeCannotChangeClassification : Type 'System.Threading.CancellationTokenRegistration' is marked as readonly in the contract so it must also be marked readonly in the implementation.
-MembersMustExist : Member 'System.Threading.CancellationTokenRegistration.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.CancellationTokenRegistration.Token.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Interlocked.MemoryBarrierProcessWide()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.LazyInitializer.EnsureInitialized<T>(T, System.Object, System.Func<T>)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Thread.GetCurrentProcessorId()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.ThreadPool.QueueUserWorkItem<TState>(System.Action<TState>, TState, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-CannotRemoveBaseTypeOrInterface : Type 'System.Threading.Timer' does not implement interface 'System.IAsyncDisposable' in the implementation but it does in the contract.
-MembersMustExist : Member 'System.Threading.Timer.DisposeAsync()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Tasks.Task.IsCompletedSuccessfully.get()' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Tasks.TaskCanceledException..ctor(System.String, System.Exception, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Tasks.TaskExtensions.ConfigureAwait(System.IAsyncDisposable, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Tasks.TaskExtensions.ConfigureAwait<T>(System.Collections.Generic.IAsyncEnumerable<T>, System.Boolean)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Threading.Tasks.TaskExtensions.WithCancellation<T>(System.Collections.Generic.IAsyncEnumerable<T>, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Threading.Tasks.ValueTask' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Threading.Tasks.ValueTask<TResult>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Threading.Tasks.Sources.IValueTaskSource' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Threading.Tasks.Sources.IValueTaskSource<TResult>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<TResult>' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Threading.Tasks.Sources.ValueTaskSourceStatus' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XCData.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XComment.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocument.LoadAsync(System.IO.Stream, System.Xml.Linq.LoadOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocument.LoadAsync(System.IO.TextReader, System.Xml.Linq.LoadOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocument.LoadAsync(System.Xml.XmlReader, System.Xml.Linq.LoadOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocument.SaveAsync(System.IO.Stream, System.Xml.Linq.SaveOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocument.SaveAsync(System.IO.TextWriter, System.Xml.Linq.SaveOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocument.SaveAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocument.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XDocumentType.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XElement.LoadAsync(System.IO.Stream, System.Xml.Linq.LoadOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XElement.LoadAsync(System.IO.TextReader, System.Xml.Linq.LoadOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XElement.LoadAsync(System.Xml.XmlReader, System.Xml.Linq.LoadOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XElement.SaveAsync(System.IO.Stream, System.Xml.Linq.SaveOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XElement.SaveAsync(System.IO.TextWriter, System.Xml.Linq.SaveOptions, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XElement.SaveAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XElement.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XNode.ReadFromAsync(System.Xml.XmlReader, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XNode.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XProcessingInstruction.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-MembersMustExist : Member 'System.Xml.Linq.XText.WriteToAsync(System.Xml.XmlWriter, System.Threading.CancellationToken)' does not exist in the implementation but it does exist in the contract.
-TypesMustExist : Type 'System.Xml.Serialization.SchemaImporter' does not exist in the implementation but it does exist in the contract.
-CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'System.Xml.Serialization.XmlAnyAttributeAttribute' changed from '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple=false)]' in the implementation.
-CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'System.Xml.Serialization.XmlNamespaceDeclarationsAttribute' changed from '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple=false)]' in the implementation.
-Total Issues: 868

From 9e2a8a6042f82fd73eb4e5f0dc0e68a99ed8e7fa Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 25 Jan 2022 09:30:24 -0500
Subject: [PATCH 056/161] Improve Regex handling of anchors (#64177)

* Improve Regex handling of anchors

- Extend search for leading anchor to support alternations.  This means that an expression like `^abc|^def` will now observe the leading `^` whereas previously it didn't.
- Add a FindFirstChar optimization that jumps to the right position for a pattern that matches a computeable max length and ends with an end anchor.

* Address PR feedback
---
 .../gen/RegexGenerator.Emitter.cs             | 153 ++++++----
 .../System/Text/RegularExpressions/Match.cs   |   3 -
 .../Text/RegularExpressions/RegexCode.cs      |   2 +-
 .../Text/RegularExpressions/RegexCompiler.cs  | 261 ++++++++++--------
 .../RegexFindOptimizations.cs                 |  78 +++++-
 .../Text/RegularExpressions/RegexNode.cs      | 178 ++++++++++--
 .../Text/RegularExpressions/RegexNodeKind.cs  |  10 +-
 .../RegularExpressions/RegexPrefixAnalyzer.cs | 163 ++++++-----
 .../tests/Regex.Match.Tests.cs                |  38 ++-
 .../tests/RegexReductionTests.cs              | 158 +++++++----
 10 files changed, 700 insertions(+), 344 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
index fabe62f5262ec1..820490c500298e 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
+++ b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
@@ -392,68 +392,111 @@ private static RequiredHelperFunctions EmitFindFirstChar(IndentedTextWriter writ
             // searching is required; otherwise, false.
             bool EmitAnchors()
             {
-                // Generate anchor checks.
-                if ((code.FindOptimizations.LeadingAnchor & (RegexPrefixAnalyzer.Beginning | RegexPrefixAnalyzer.Start | RegexPrefixAnalyzer.EndZ | RegexPrefixAnalyzer.End | RegexPrefixAnalyzer.Bol)) != 0)
+                // Anchors that fully implement FindFirstChar, with a check that leads to immediate success or failure determination.
+                switch (code.FindOptimizations.FindMode)
                 {
-                    switch (code.FindOptimizations.LeadingAnchor)
-                    {
-                        case RegexPrefixAnalyzer.Beginning:
-                            writer.WriteLine("// Beginning \\A anchor");
-                            additionalDeclarations.Add("int beginning = base.runtextbeg;");
-                            using (EmitBlock(writer, "if (pos > beginning)"))
-                            {
-                                writer.WriteLine($"goto {NoStartingPositionFound};");
-                            }
-                            writer.WriteLine("return true;");
-                            return true;
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Beginning:
+                        writer.WriteLine("// Beginning \\A anchor");
+                        additionalDeclarations.Add("int beginning = base.runtextbeg;");
+                        using (EmitBlock(writer, "if (pos > beginning)"))
+                        {
+                            writer.WriteLine($"goto {NoStartingPositionFound};");
+                        }
+                        writer.WriteLine("return true;");
+                        return true;
+
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Start:
+                        writer.WriteLine("// Start \\G anchor");
+                        using (EmitBlock(writer, "if (pos > base.runtextstart)"))
+                        {
+                            writer.WriteLine($"goto {NoStartingPositionFound};");
+                        }
+                        writer.WriteLine("return true;");
+                        return true;
+
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_EndZ:
+                        writer.WriteLine("// Leading end \\Z anchor");
+                        using (EmitBlock(writer, "if (pos < end - 1)"))
+                        {
+                            writer.WriteLine("base.runtextpos = end - 1;");
+                        }
+                        writer.WriteLine("return true;");
+                        return true;
+
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_End:
+                        writer.WriteLine("// Leading end \\z anchor");
+                        using (EmitBlock(writer, "if (pos < end)"))
+                        {
+                            writer.WriteLine("base.runtextpos = end;");
+                        }
+                        writer.WriteLine("return true;");
+                        return true;
 
-                        case RegexPrefixAnalyzer.Start:
-                            writer.WriteLine("// Start \\G anchor");
-                            using (EmitBlock(writer, "if (pos > base.runtextstart)"))
+                    case FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_EndZ:
+                        // Jump to the end, minus the min required length, which in this case is actually the fixed length, minus 1 (for a possible ending \n).
+                        writer.WriteLine("// Trailing end \\Z anchor with fixed-length match");
+                        using (EmitBlock(writer, $"if (pos < end - {code.Tree.MinRequiredLength + 1})"))
+                        {
+                            writer.WriteLine($"base.runtextpos = end - {code.Tree.MinRequiredLength + 1};");
+                        }
+                        writer.WriteLine("return true;");
+                        return true;
+
+                    case FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_End:
+                        // Jump to the end, minus the min required length, which in this case is actually the fixed length.
+                        writer.WriteLine("// Trailing end \\z anchor with fixed-length match");
+                        using (EmitBlock(writer, $"if (pos < end - {code.Tree.MinRequiredLength})"))
+                        {
+                            writer.WriteLine($"base.runtextpos = end - {code.Tree.MinRequiredLength};");
+                        }
+                        writer.WriteLine("return true;");
+                        return true;
+                }
+
+                // Now handle anchors that boost the position but may not determine immediate success or failure.
+
+                switch (code.FindOptimizations.LeadingAnchor)
+                {
+                    case RegexNodeKind.Bol:
+                        // Optimize the handling of a Beginning-Of-Line (BOL) anchor.  BOL is special, in that unlike
+                        // other anchors like Beginning, there are potentially multiple places a BOL can match.  So unlike
+                        // the other anchors, which all skip all subsequent processing if found, with BOL we just use it
+                        // to boost our position to the next line, and then continue normally with any searches.
+                        writer.WriteLine("// Beginning-of-line anchor");
+                        additionalDeclarations.Add("global::System.ReadOnlySpan<char> inputSpan = base.runtext;");
+                        additionalDeclarations.Add("int beginning = base.runtextbeg;");
+                        using (EmitBlock(writer, "if (pos > beginning && inputSpan[pos - 1] != '\\n')"))
+                        {
+                            writer.WriteLine("int newlinePos = global::System.MemoryExtensions.IndexOf(inputSpan.Slice(pos), '\\n');");
+                            using (EmitBlock(writer, "if (newlinePos < 0 || newlinePos + pos + 1 > end)"))
                             {
                                 writer.WriteLine($"goto {NoStartingPositionFound};");
                             }
-                            writer.WriteLine("return true;");
-                            return true;
+                            writer.WriteLine("pos = newlinePos + pos + 1;");
+                        }
+                        writer.WriteLine();
+                        break;
+                }
 
-                        case RegexPrefixAnalyzer.EndZ:
-                            writer.WriteLine("// End \\Z anchor");
-                            using (EmitBlock(writer, "if (pos < end - 1)"))
-                            {
-                                writer.WriteLine("base.runtextpos = end - 1;");
-                            }
-                            writer.WriteLine("return true;");
-                            return true;
+                switch (code.FindOptimizations.TrailingAnchor)
+                {
+                    case RegexNodeKind.End when code.FindOptimizations.MaxPossibleLength is int maxLength:
+                        writer.WriteLine("// End \\z anchor with maximum-length match");
+                        using (EmitBlock(writer, $"if (pos < end - {maxLength})"))
+                        {
+                            writer.WriteLine($"pos = end - {maxLength};");
+                        }
+                        writer.WriteLine();
+                        break;
 
-                        case RegexPrefixAnalyzer.End:
-                            writer.WriteLine("// End \\z anchor");
-                            using (EmitBlock(writer, "if (pos < end)"))
-                            {
-                                writer.WriteLine("base.runtextpos = end;");
-                            }
-                            writer.WriteLine("return true;");
-                            return true;
-
-                        case RegexPrefixAnalyzer.Bol:
-                            // Optimize the handling of a Beginning-Of-Line (BOL) anchor.  BOL is special, in that unlike
-                            // other anchors like Beginning, there are potentially multiple places a BOL can match.  So unlike
-                            // the other anchors, which all skip all subsequent processing if found, with BOL we just use it
-                            // to boost our position to the next line, and then continue normally with any searches.
-                            writer.WriteLine("// Beginning-of-line anchor");
-                            additionalDeclarations.Add("global::System.ReadOnlySpan<char> inputSpan = base.runtext;");
-                            additionalDeclarations.Add("int beginning = base.runtextbeg;");
-                            using (EmitBlock(writer, "if (pos > beginning && inputSpan[pos - 1] != '\\n')"))
-                            {
-                                writer.WriteLine("int newlinePos = global::System.MemoryExtensions.IndexOf(inputSpan.Slice(pos), '\\n');");
-                                using (EmitBlock(writer, "if (newlinePos < 0 || newlinePos + pos + 1 > end)"))
-                                {
-                                    writer.WriteLine($"goto {NoStartingPositionFound};");
-                                }
-                                writer.WriteLine("pos = newlinePos + pos + 1;");
-                            }
-                            writer.WriteLine();
-                            break;
-                    }
+                    case RegexNodeKind.EndZ when code.FindOptimizations.MaxPossibleLength is int maxLength:
+                        writer.WriteLine("// End \\Z anchor with maximum-length match");
+                        using (EmitBlock(writer, $"if (pos < end - {maxLength + 1})"))
+                        {
+                            writer.WriteLine($"pos = end - {maxLength + 1};");
+                        }
+                        writer.WriteLine();
+                        break;
                 }
 
                 return false;
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs
index b7f2f032e78a82..b941d1ad8d7a2f 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs
@@ -61,9 +61,6 @@ internal Match(Regex? regex, int capcount, string text, int begpos, int len, int
             _textend = begpos + len;
             _textstart = startpos;
             _balancing = false;
-
-            Debug.Assert(!(_textbeg < 0 || _textstart < _textbeg || _textend < _textstart || Text.Length < _textend),
-                "The parameters are out of range.");
         }
 
         /// <summary>Returns an empty Match object.</summary>
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs
index d51ca826fd71c6..76caec6647ad21 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs
@@ -401,7 +401,7 @@ public override string ToString()
             var sb = new StringBuilder();
 
             sb.AppendLine($"Direction:  {(RightToLeft ? "right-to-left" : "left-to-right")}");
-            sb.AppendLine($"Anchor:     {RegexPrefixAnalyzer.AnchorDescription(FindOptimizations.LeadingAnchor)}");
+            sb.AppendLine($"Anchor:     {FindOptimizations.LeadingAnchor}");
             sb.AppendLine();
             for (int i = 0; i < Codes.Length; i += OpcodeSize(Codes[i]))
             {
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
index 2145a5dec334d2..1c03616ef37931 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
@@ -465,134 +465,173 @@ FindNextStartingPositionMode.FixedSets_LeftToRight_CaseInsensitive or
             // searching is required; otherwise, false.
             bool GenerateAnchors()
             {
-                // Generate anchor checks.
-                if ((_code.FindOptimizations.LeadingAnchor & (RegexPrefixAnalyzer.Beginning | RegexPrefixAnalyzer.Start | RegexPrefixAnalyzer.EndZ | RegexPrefixAnalyzer.End | RegexPrefixAnalyzer.Bol)) != 0)
+                Label label;
+
+                // Anchors that fully implement FindFirstChar, with a check that leads to immediate success or failure determination.
+                switch (_code.FindOptimizations.FindMode)
                 {
-                    switch (_code.FindOptimizations.LeadingAnchor)
-                    {
-                        case RegexPrefixAnalyzer.Beginning:
-                            {
-                                Label l1 = DefineLabel();
-                                Ldloc(pos);
-                                Ldthisfld(s_runtextbegField);
-                                Ble(l1);
-                                Br(returnFalse);
-                                MarkLabel(l1);
-                            }
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Beginning:
+                        label = DefineLabel();
+                        Ldloc(pos);
+                        Ldthisfld(s_runtextbegField);
+                        Ble(label);
+                        Br(returnFalse);
+                        MarkLabel(label);
+                        Ldc(1);
+                        Ret();
+                        return true;
+
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Start:
+                        label = DefineLabel();
+                        Ldloc(pos);
+                        Ldthisfld(s_runtextstartField);
+                        Ble(label);
+                        Br(returnFalse);
+                        MarkLabel(label);
+                        Ldc(1);
+                        Ret();
+                        return true;
+
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_EndZ:
+                        label = DefineLabel();
+                        Ldloc(pos);
+                        Ldloc(end);
+                        Ldc(1);
+                        Sub();
+                        Bge(label);
+                        Ldthis();
+                        Ldloc(end);
+                        Ldc(1);
+                        Sub();
+                        Stfld(s_runtextposField);
+                        MarkLabel(label);
+                        Ldc(1);
+                        Ret();
+                        return true;
+
+                    case FindNextStartingPositionMode.LeadingAnchor_LeftToRight_End:
+                        label = DefineLabel();
+                        Ldloc(pos);
+                        Ldloc(end);
+                        Bge(label);
+                        Ldthis();
+                        Ldloc(end);
+                        Stfld(s_runtextposField);
+                        MarkLabel(label);
+                        Ldc(1);
+                        Ret();
+                        return true;
+
+                    case FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_End:
+                    case FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_EndZ:
+                        // Jump to the end, minus the min required length, which in this case is actually the fixed length.
+                        {
+                            int extraNewlineBump = _code.FindOptimizations.FindMode == FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_EndZ ? 1 : 0;
+                            label = DefineLabel();
+                            Ldloc(pos);
+                            Ldloc(end);
+                            Ldc(_code.Tree.MinRequiredLength + extraNewlineBump);
+                            Sub();
+                            Bge(label);
+                            Ldthis();
+                            Ldloc(end);
+                            Ldc(_code.Tree.MinRequiredLength + extraNewlineBump);
+                            Sub();
+                            Stfld(s_runtextposField);
+                            MarkLabel(label);
                             Ldc(1);
                             Ret();
                             return true;
+                        }
+                }
 
-                        case RegexPrefixAnalyzer.Start:
-                            {
-                                Label l1 = DefineLabel();
-                                Ldloc(pos);
-                                Ldthisfld(s_runtextstartField);
-                                Ble(l1);
-                                Br(returnFalse);
-                                MarkLabel(l1);
-                            }
+                // Now handle anchors that boost the position but don't determine immediate success or failure.
+
+                switch (_code.FindOptimizations.LeadingAnchor)
+                {
+                    case RegexNodeKind.Bol:
+                        {
+                            // Optimize the handling of a Beginning-Of-Line (BOL) anchor.  BOL is special, in that unlike
+                            // other anchors like Beginning, there are potentially multiple places a BOL can match.  So unlike
+                            // the other anchors, which all skip all subsequent processing if found, with BOL we just use it
+                            // to boost our position to the next line, and then continue normally with any prefix or char class searches.
+
+                            label = DefineLabel();
+
+                            // if (pos > runtextbeg...
+                            Ldloc(pos!);
+                            Ldthisfld(s_runtextbegField);
+                            Ble(label);
+
+                            // ... && inputSpan[pos - 1] != '\n') { ... }
+                            Ldloca(inputSpan);
+                            Ldloc(pos);
                             Ldc(1);
-                            Ret();
-                            return true;
+                            Sub();
+                            Call(s_spanGetItemMethod);
+                            LdindU2();
+                            Ldc('\n');
+                            Beq(label);
 
-                        case RegexPrefixAnalyzer.EndZ:
+                            // int tmp = inputSpan.Slice(pos).IndexOf('\n');
+                            Ldloca(inputSpan);
+                            Ldloc(pos);
+                            Call(s_spanSliceIntMethod);
+                            Ldc('\n');
+                            Call(s_spanIndexOfChar);
+                            using (RentedLocalBuilder newlinePos = RentInt32Local())
                             {
-                                Label l1 = DefineLabel();
+                                Stloc(newlinePos);
+
+                                // if (newlinePos < 0 || newlinePos + pos + 1 > end)
+                                // {
+                                //     base.runtextpos = end;
+                                //     return false;
+                                // }
+                                Ldloc(newlinePos);
+                                Ldc(0);
+                                Blt(returnFalse);
+                                Ldloc(newlinePos);
                                 Ldloc(pos);
-                                Ldloc(end);
+                                Add();
                                 Ldc(1);
-                                Sub();
-                                Bge(l1);
-                                Ldthis();
+                                Add();
                                 Ldloc(end);
-                                Ldc(1);
-                                Sub();
-                                Stfld(s_runtextposField);
-                                MarkLabel(l1);
-                            }
-                            Ldc(1);
-                            Ret();
-                            return true;
+                                Bgt(returnFalse);
 
-                        case RegexPrefixAnalyzer.End:
-                            {
-                                Label l1 = DefineLabel();
+                                // pos += newlinePos + 1;
                                 Ldloc(pos);
-                                Ldloc(end);
-                                Bge(l1);
-                                Ldthis();
-                                Ldloc(end);
-                                Stfld(s_runtextposField);
-                                MarkLabel(l1);
+                                Ldloc(newlinePos);
+                                Add();
+                                Ldc(1);
+                                Add();
+                                Stloc(pos);
                             }
-                            Ldc(1);
-                            Ret();
-                            return true;
-
-                        case RegexPrefixAnalyzer.Bol:
-                            {
-                                // Optimize the handling of a Beginning-Of-Line (BOL) anchor.  BOL is special, in that unlike
-                                // other anchors like Beginning, there are potentially multiple places a BOL can match.  So unlike
-                                // the other anchors, which all skip all subsequent processing if found, with BOL we just use it
-                                // to boost our position to the next line, and then continue normally with any prefix or char class searches.
 
-                                Label atBeginningOfLine = DefineLabel();
-
-                                // if (pos > runtextbeg...
-                                Ldloc(pos!);
-                                Ldthisfld(s_runtextbegField);
-                                Ble(atBeginningOfLine);
+                            MarkLabel(label);
+                        }
+                        break;
+                }
 
-                                // ... && inputSpan[pos - 1] != '\n') { ... }
-                                Ldloca(inputSpan);
-                                Ldloc(pos);
-                                Ldc(1);
-                                Sub();
-                                Call(s_spanGetItemMethod);
-                                LdindU2();
-                                Ldc('\n');
-                                Beq(atBeginningOfLine);
-
-                                // int tmp = inputSpan.Slice(pos).IndexOf('\n');
-                                Ldloca(inputSpan);
-                                Ldloc(pos);
-                                Call(s_spanSliceIntMethod);
-                                Ldc('\n');
-                                Call(s_spanIndexOfChar);
-                                using (RentedLocalBuilder newlinePos = RentInt32Local())
-                                {
-                                    Stloc(newlinePos);
-
-                                    // if (newlinePos < 0 || newlinePos + pos + 1 > end)
-                                    // {
-                                    //     base.runtextpos = end;
-                                    //     return false;
-                                    // }
-                                    Ldloc(newlinePos);
-                                    Ldc(0);
-                                    Blt(returnFalse);
-                                    Ldloc(newlinePos);
-                                    Ldloc(pos);
-                                    Add();
-                                    Ldc(1);
-                                    Add();
-                                    Ldloc(end);
-                                    Bgt(returnFalse);
-
-                                    // pos += newlinePos + 1;
-                                    Ldloc(pos);
-                                    Ldloc(newlinePos);
-                                    Add();
-                                    Ldc(1);
-                                    Add();
-                                    Stloc(pos);
-                                }
-
-                                MarkLabel(atBeginningOfLine);
-                            }
+                switch (_code.FindOptimizations.TrailingAnchor)
+                {
+                    case RegexNodeKind.End or RegexNodeKind.EndZ when _code.FindOptimizations.MaxPossibleLength is int maxLength:
+                        // Jump to the end, minus the max allowed length.
+                        {
+                            int extraNewlineBump = _code.FindOptimizations.FindMode == FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_EndZ ? 1 : 0;
+                            label = DefineLabel();
+                            Ldloc(pos);
+                            Ldloc(end);
+                            Ldc(maxLength + extraNewlineBump);
+                            Sub();
+                            Bge(label);
+                            Ldloc(end);
+                            Ldc(maxLength + extraNewlineBump);
+                            Sub();
+                            Stloc(pos);
+                            MarkLabel(label);
                             break;
-                    }
+                        }
                 }
 
                 return false;
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs
index e3c760c2728be5..ee96e7e5cc8470 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs
@@ -10,7 +10,8 @@ namespace System.Text.RegularExpressions
     /// <summary>Contains state and provides operations related to finding the next location a match could possibly begin.</summary>
     internal sealed class RegexFindOptimizations
     {
-        /// <summary>The minimum required length an input need be to match the pattern.  May be 0.</summary>
+        /// <summary>The minimum required length an input need be to match the pattern.</summary>
+        /// <remarks>0 is a valid minimum length.  This value may also be the max (and hence fixed) length of the expression.</remarks>
         private readonly int _minRequiredLength;
         /// <summary>True if the input should be processed right-to-left rather than left-to-right.</summary>
         private readonly bool _rightToLeft;
@@ -27,28 +28,48 @@ public RegexFindOptimizations(RegexTree tree, CultureInfo culture)
 
             // Compute any anchor starting the expression.  If there is one, we won't need to search for anything,
             // as we can just match at that single location.
-            LeadingAnchor = RegexPrefixAnalyzer.FindLeadingAnchor(tree);
-            if (_rightToLeft)
+            LeadingAnchor = RegexPrefixAnalyzer.FindLeadingAnchor(tree.Root);
+            if (_rightToLeft && LeadingAnchor == RegexNodeKind.Bol)
             {
                 // Filter out Bol for RightToLeft, as we don't currently optimize for it.
-                LeadingAnchor &= ~RegexPrefixAnalyzer.Bol;
+                LeadingAnchor = RegexNodeKind.Unknown;
             }
-            if ((LeadingAnchor & (RegexPrefixAnalyzer.Beginning | RegexPrefixAnalyzer.Start | RegexPrefixAnalyzer.EndZ | RegexPrefixAnalyzer.End)) != 0)
+            if (LeadingAnchor is RegexNodeKind.Beginning or RegexNodeKind.Start or RegexNodeKind.EndZ or RegexNodeKind.End)
             {
                 FindMode = (LeadingAnchor, _rightToLeft) switch
                 {
-                    (RegexPrefixAnalyzer.Beginning, false) => FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Beginning,
-                    (RegexPrefixAnalyzer.Beginning, true) => FindNextStartingPositionMode.LeadingAnchor_RightToLeft_Beginning,
-                    (RegexPrefixAnalyzer.Start, false) => FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Start,
-                    (RegexPrefixAnalyzer.Start, true) => FindNextStartingPositionMode.LeadingAnchor_RightToLeft_Start,
-                    (RegexPrefixAnalyzer.End, false) => FindNextStartingPositionMode.LeadingAnchor_LeftToRight_End,
-                    (RegexPrefixAnalyzer.End, true) => FindNextStartingPositionMode.LeadingAnchor_RightToLeft_End,
+                    (RegexNodeKind.Beginning, false) => FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Beginning,
+                    (RegexNodeKind.Beginning, true) => FindNextStartingPositionMode.LeadingAnchor_RightToLeft_Beginning,
+                    (RegexNodeKind.Start, false) => FindNextStartingPositionMode.LeadingAnchor_LeftToRight_Start,
+                    (RegexNodeKind.Start, true) => FindNextStartingPositionMode.LeadingAnchor_RightToLeft_Start,
+                    (RegexNodeKind.End, false) => FindNextStartingPositionMode.LeadingAnchor_LeftToRight_End,
+                    (RegexNodeKind.End, true) => FindNextStartingPositionMode.LeadingAnchor_RightToLeft_End,
                     (_, false) => FindNextStartingPositionMode.LeadingAnchor_LeftToRight_EndZ,
                     (_, true) => FindNextStartingPositionMode.LeadingAnchor_RightToLeft_EndZ,
                 };
                 return;
             }
 
+            // Compute any anchor trailing the expression.  If there is one, and we can also compute a fixed length
+            // for the whole expression, we can use that to quickly jump to the right location in the input.
+            if (!_rightToLeft) // haven't added FindNextStartingPositionMode support for RTL
+            {
+                TrailingAnchor = RegexPrefixAnalyzer.FindTrailingAnchor(tree.Root);
+                if (TrailingAnchor is RegexNodeKind.End or RegexNodeKind.EndZ &&
+                    tree.Root.ComputeMaxLength() is int maxLength)
+                {
+                    Debug.Assert(maxLength >= _minRequiredLength, $"{maxLength} should have been greater than {_minRequiredLength} minimum");
+                    MaxPossibleLength = maxLength;
+                    if (_minRequiredLength == maxLength)
+                    {
+                        FindMode = TrailingAnchor == RegexNodeKind.End ?
+                            FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_End :
+                            FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_EndZ;
+                        return;
+                    }
+                }
+            }
+
             // If there's a leading case-sensitive substring, just use IndexOf and inherit all of its optimizations.
             string caseSensitivePrefix = RegexPrefixAnalyzer.FindCaseSensitivePrefix(tree.Root);
             if (caseSensitivePrefix.Length > 1)
@@ -183,8 +204,18 @@ public RegexFindOptimizations(RegexTree tree, CultureInfo culture)
         /// <summary>Gets the selected mode for performing the next <see cref="TryFindNextStartingPosition"/> operation</summary>
         public FindNextStartingPositionMode FindMode { get; } = FindNextStartingPositionMode.NoSearch;
 
-        /// <summary>Gets the leading anchor, if one exists (RegexPrefixAnalyzer.Bol, etc).</summary>
-        public int LeadingAnchor { get; }
+        /// <summary>Gets the leading anchor (e.g. RegexNodeKind.Bol) if one exists and was computed.</summary>
+        public RegexNodeKind LeadingAnchor { get; }
+
+        /// <summary>Gets the trailing anchor (e.g. RegexNodeKind.Bol) if one exists and was computed.</summary>
+        public RegexNodeKind TrailingAnchor { get; }
+
+        /// <summary>The maximum possible length an input could be to match the pattern.</summary>
+        /// <remarks>
+        /// This is currently only set when <see cref="TrailingAnchor"/> is found to be an end anchor.
+        /// That can be expanded in the future as needed.
+        /// </remarks>
+        public int? MaxPossibleLength { get; }
 
         /// <summary>Gets the leading prefix.  May be an empty string.</summary>
         public string LeadingCaseSensitivePrefix { get; } = string.Empty;
@@ -230,7 +261,7 @@ public bool TryFindNextStartingPosition(ReadOnlySpan<char> textSpan, ref int pos
             // other anchors like Beginning, there are potentially multiple places a BOL can match.  So unlike
             // the other anchors, which all skip all subsequent processing if found, with BOL we just use it
             // to boost our position to the next line, and then continue normally with any searches.
-            if (LeadingAnchor == RegexPrefixAnalyzer.Bol)
+            if (LeadingAnchor == RegexNodeKind.Bol)
             {
                 // If we're not currently positioned at the beginning of a line (either
                 // the beginning of the string or just after a line feed), find the next
@@ -315,6 +346,20 @@ public bool TryFindNextStartingPosition(ReadOnlySpan<char> textSpan, ref int pos
                     }
                     return true;
 
+                case FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_EndZ:
+                    if (pos < end - _minRequiredLength - 1)
+                    {
+                        pos = end - _minRequiredLength - 1;
+                    }
+                    return true;
+
+                case FindNextStartingPositionMode.TrailingAnchor_FixedLength_LeftToRight_End:
+                    if (pos < end - _minRequiredLength)
+                    {
+                        pos = end - _minRequiredLength;
+                    }
+                    return true;
+
                 // There's a case-sensitive prefix.  Search for it with ordinal IndexOf.
 
                 case FindNextStartingPositionMode.LeadingPrefix_LeftToRight_CaseSensitive:
@@ -698,6 +743,11 @@ internal enum FindNextStartingPositionMode
         /// <summary>An "end" anchor at the beginning of the right-to-left pattern.  This is rare.</summary>
         LeadingAnchor_RightToLeft_End,
 
+        /// <summary>An "end" anchor at the end of the pattern, with the pattern always matching a fixed-length expression.</summary>
+        TrailingAnchor_FixedLength_LeftToRight_End,
+        /// <summary>An "endz" anchor at the end of the pattern, with the pattern always matching a fixed-length expression.</summary>
+        TrailingAnchor_FixedLength_LeftToRight_EndZ,
+
         /// <summary>A case-sensitive multi-character substring at the beginning of the pattern.</summary>
         LeadingPrefix_LeftToRight_CaseSensitive,
         /// <summary>A case-sensitive multi-character substring at the beginning of the right-to-left pattern.</summary>
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
index ad760e95e39142..945f9ac2b4f2de 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
@@ -232,7 +232,7 @@ private void ValidateFinalTreeInvariants()
                     case RegexNodeKind.Setloopatomic:
                     case RegexNodeKind.Start:
                     case RegexNodeKind.UpdateBumpalong:
-                        Debug.Assert(childCount == 0, $"Expected zero children for {node.TypeName}, got {childCount}.");
+                        Debug.Assert(childCount == 0, $"Expected zero children for {node.Kind}, got {childCount}.");
                         break;
 
                     case RegexNodeKind.Atomic:
@@ -241,20 +241,20 @@ private void ValidateFinalTreeInvariants()
                     case RegexNodeKind.Loop:
                     case RegexNodeKind.NegativeLookaround:
                     case RegexNodeKind.PositiveLookaround:
-                        Debug.Assert(childCount == 1, $"Expected one and only one child for {node.TypeName}, got {childCount}.");
+                        Debug.Assert(childCount == 1, $"Expected one and only one child for {node.Kind}, got {childCount}.");
                         break;
 
                     case RegexNodeKind.BackreferenceConditional:
-                        Debug.Assert(childCount == 2, $"Expected two children for {node.TypeName}, got {childCount}");
+                        Debug.Assert(childCount == 2, $"Expected two children for {node.Kind}, got {childCount}");
                         break;
 
                     case RegexNodeKind.ExpressionConditional:
-                        Debug.Assert(childCount == 3, $"Expected three children for {node.TypeName}, got {childCount}");
+                        Debug.Assert(childCount == 3, $"Expected three children for {node.Kind}, got {childCount}");
                         break;
 
                     case RegexNodeKind.Concatenate:
                     case RegexNodeKind.Alternate:
-                        Debug.Assert(childCount >= 2, $"Expected at least two children for {node.TypeName}, got {childCount}.");
+                        Debug.Assert(childCount >= 2, $"Expected at least two children for {node.Kind}, got {childCount}.");
                         break;
 
                     default:
@@ -274,11 +274,11 @@ private void ValidateFinalTreeInvariants()
                     case RegexNodeKind.Setloop:
                     case RegexNodeKind.Setloopatomic:
                     case RegexNodeKind.Setlazy:
-                        Debug.Assert(!string.IsNullOrEmpty(node.Str), $"Expected non-null, non-empty string for {node.TypeName}.");
+                        Debug.Assert(!string.IsNullOrEmpty(node.Str), $"Expected non-null, non-empty string for {node.Kind}.");
                         break;
 
                     default:
-                        Debug.Assert(node.Str is null, $"Expected null string for {node.TypeName}, got \"{node.Str}\".");
+                        Debug.Assert(node.Str is null, $"Expected null string for {node.Kind}, got \"{node.Str}\".");
                         break;
                 }
             }
@@ -2125,7 +2125,7 @@ public int ComputeMinLength()
                 case RegexNodeKind.Lazyloop:
                 case RegexNodeKind.Loop:
                     // A node graph repeated at least M times.
-                    return (int)Math.Min(int.MaxValue, (long)M * Child(0).ComputeMinLength());
+                    return (int)Math.Min(int.MaxValue - 1, (long)M * Child(0).ComputeMinLength());
 
                 case RegexNodeKind.Alternate:
                     // The minimum required length for any of the alternation's branches.
@@ -2157,7 +2157,7 @@ public int ComputeMinLength()
                         {
                             sum += Child(i).ComputeMinLength();
                         }
-                        return (int)Math.Min(int.MaxValue, sum);
+                        return (int)Math.Min(int.MaxValue - 1, sum);
                     }
 
                 case RegexNodeKind.Atomic:
@@ -2170,9 +2170,9 @@ public int ComputeMinLength()
                 case RegexNodeKind.Empty:
                 case RegexNodeKind.Nothing:
                 case RegexNodeKind.UpdateBumpalong:
-                // Nothing to match. In the future, we could potentially use Nothing to say that the min length
-                // is infinite, but that would require a different structure, as that would only apply if the
-                // Nothing match is required in all cases (rather than, say, as one branch of an alternation).
+                    // Nothing to match. In the future, we could potentially use Nothing to say that the min length
+                    // is infinite, but that would require a different structure, as that would only apply if the
+                    // Nothing match is required in all cases (rather than, say, as one branch of an alternation).
                 case RegexNodeKind.Beginning:
                 case RegexNodeKind.Bol:
                 case RegexNodeKind.Boundary:
@@ -2183,20 +2183,154 @@ public int ComputeMinLength()
                 case RegexNodeKind.NonBoundary:
                 case RegexNodeKind.NonECMABoundary:
                 case RegexNodeKind.Start:
-                // Difficult to glean anything meaningful from boundaries or results only known at run time.
                 case RegexNodeKind.NegativeLookaround:
                 case RegexNodeKind.PositiveLookaround:
-                // Lookaheads/behinds could potentially be included in the future, but that will require
-                // a different structure, as they can't be added as part of a concatenation, since they overlap
-                // with what comes after.
+                    // Zero-width
                 case RegexNodeKind.Backreference:
-                    // Constructs requiring data at runtime from the matching pattern can't influence min length.
+                    // Requires matching data available only at run-time.  In the future, we could choose to find
+                    // and follow the capture group this aligns with, while being careful not to end up in an
+                    // infinite cycle.
                     return 0;
 
                 default:
-#if DEBUG
-                    Debug.Fail($"Unknown node: {TypeName}");
-#endif
+                    Debug.Fail($"Unknown node: {Kind}");
+                    goto case RegexNodeKind.Empty;
+            }
+        }
+
+        /// <summary>Computes a maximum length of any string that could possibly match.</summary>
+        /// <returns>The maximum length of any string that could possibly match, or null if the length may not always be the same.</returns>
+        /// <remarks>
+        /// e.g. abc[def](gh|ijklmnop) => 12
+        /// </remarks>
+        public int? ComputeMaxLength()
+        {
+            if (!StackHelper.TryEnsureSufficientExecutionStack())
+            {
+                // If we can't recur further, assume there's no minimum we can enforce.
+                return null;
+            }
+
+            switch (Kind)
+            {
+                case RegexNodeKind.One:
+                case RegexNodeKind.Notone:
+                case RegexNodeKind.Set:
+                    // Single character.
+                    return 1;
+
+                case RegexNodeKind.Multi:
+                    // Every character in the string needs to match.
+                    return Str!.Length;
+
+                case RegexNodeKind.Notonelazy or RegexNodeKind.Notoneloop or RegexNodeKind.Notoneloopatomic or
+                     RegexNodeKind.Onelazy or RegexNodeKind.Oneloop or RegexNodeKind.Oneloopatomic or
+                     RegexNodeKind.Setlazy or RegexNodeKind.Setloop or RegexNodeKind.Setloopatomic:
+                    // Return the max number of iterations if there's an upper bound, or null if it's infinite
+                    return N == int.MaxValue ? null : N;
+
+                case RegexNodeKind.Loop or RegexNodeKind.Lazyloop:
+                    if (N != int.MaxValue)
+                    {
+                        // A node graph repeated a fixed number of times
+                        if (Child(0).ComputeMaxLength() is int childMaxLength)
+                        {
+                            long maxLength = (long)N * childMaxLength;
+                            if (maxLength < int.MaxValue)
+                            {
+                                return (int)maxLength;
+                            }
+                        }
+                    }
+                    return null;
+
+                case RegexNodeKind.Alternate:
+                    // The maximum length of any child branch, as long as they all have one.
+                    {
+                        int childCount = ChildCount();
+                        Debug.Assert(childCount >= 2);
+                        if (Child(0).ComputeMaxLength() is not int maxLength)
+                        {
+                            return null;
+                        }
+
+                        for (int i = 1; i < childCount; i++)
+                        {
+                            if (Child(i).ComputeMaxLength() is not int next)
+                            {
+                                return null;
+                            }
+
+                            maxLength = Math.Max(maxLength, next);
+                        }
+
+                        return maxLength;
+                    }
+
+                case RegexNodeKind.BackreferenceConditional:
+                case RegexNodeKind.ExpressionConditional:
+                    // The maximum length of either child branch, as long as they both have one.. The condition for an expression conditional is a zero-width assertion.
+                    {
+                        int i = Kind == RegexNodeKind.BackreferenceConditional ? 0 : 1;
+                        return Child(i).ComputeMaxLength() is int yes && Child(i + 1).ComputeMaxLength() is int no ?
+                            Math.Max(yes, no) :
+                            null;
+                    }
+
+                case RegexNodeKind.Concatenate:
+                    // The sum of all of the concatenation's children's max lengths, as long as they all have one.
+                    {
+                        long sum = 0;
+                        int childCount = ChildCount();
+                        for (int i = 0; i < childCount; i++)
+                        {
+                            if (Child(i).ComputeMaxLength() is not int length)
+                            {
+                                return null;
+                            }
+                            sum += length;
+                        }
+
+                        if (sum < int.MaxValue)
+                        {
+                            return (int)sum;
+                        }
+
+                        return null;
+                    }
+
+                case RegexNodeKind.Atomic:
+                case RegexNodeKind.Capture:
+                    // For groups, we just delegate to the sole child.
+                    Debug.Assert(ChildCount() == 1);
+                    return Child(0).ComputeMaxLength();
+
+                case RegexNodeKind.Empty:
+                case RegexNodeKind.Nothing:
+                case RegexNodeKind.UpdateBumpalong:
+                case RegexNodeKind.Beginning:
+                case RegexNodeKind.Bol:
+                case RegexNodeKind.Boundary:
+                case RegexNodeKind.ECMABoundary:
+                case RegexNodeKind.End:
+                case RegexNodeKind.EndZ:
+                case RegexNodeKind.Eol:
+                case RegexNodeKind.NonBoundary:
+                case RegexNodeKind.NonECMABoundary:
+                case RegexNodeKind.Start:
+                case RegexNodeKind.PositiveLookaround:
+                case RegexNodeKind.NegativeLookaround:
+                    // Zero-width
+                    return 0;
+
+                case RegexNodeKind.Backreference:
+                    // Requires matching data available only at run-time.  In the future, we could choose to find
+                    // and follow the capture group this aligns with, while being careful not to end up in an
+                    // infinite cycle.
+                    return null;
+
+                default:
+                    Debug.Fail($"Unknown node: {Kind}");
                     goto case RegexNodeKind.Empty;
             }
         }
@@ -2416,12 +2550,10 @@ public bool IsInLoop()
         }
 
 #if DEBUG
-        private string TypeName => Kind.ToString();
-
         [ExcludeFromCodeCoverage]
         public string Description()
         {
-            var sb = new StringBuilder(TypeName);
+            var sb = new StringBuilder(Kind.ToString());
 
             if ((Options & RegexOptions.ExplicitCapture) != 0) sb.Append("-C");
             if ((Options & RegexOptions.IgnoreCase) != 0) sb.Append("-I");
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs
index ab4ea881087c5c..dcf1097ea3ec70 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs
@@ -1,17 +1,15 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using System.Threading;
-
 namespace System.Text.RegularExpressions
 {
     /// <summary>Specifies the kind of a <see cref="RegexNode"/>.</summary>
     internal enum RegexNodeKind
     {
+        /// <summary>Unknown node type.</summary>
+        /// <remarks>This should never occur on an actual node, and instead is used as a sentinel.</remarks>
+        Unknown = 0,
+
         // The following are leaves (no children) and correspond to primitive operations in the regular expression.
 
         /// <summary>A specific character, e.g. `a`.</summary>
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs
index 692ee7d5557c1a..c3e80fc9913718 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexPrefixAnalyzer.cs
@@ -3,7 +3,6 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -17,16 +16,6 @@ internal ref struct RegexPrefixAnalyzer
         private const RegexNodeKind BeforeChild = (RegexNodeKind)64;
         private const RegexNodeKind AfterChild = (RegexNodeKind)128;
 
-        // where the regex can be pegged
-        public const int Beginning = 0x0001;
-        public const int Bol = 0x0002;
-        public const int Start = 0x0004;
-        public const int Eol = 0x0008;
-        public const int EndZ = 0x0010;
-        public const int End = 0x0020;
-        public const int Boundary = 0x0040;
-        public const int ECMABoundary = 0x0080;
-
         private readonly List<RegexFC> _fcStack;
         private ValueListBuilder<int> _intStack;    // must not be readonly
         private bool _skipAllChildren;              // don't process any more children at the current level
@@ -654,94 +643,116 @@ public static (RegexNode LoopNode, (char Char, string? String, char[]? Chars) Li
             return null;
         }
 
-        /// <summary>Takes a RegexTree and computes the leading anchor that it encounters.</summary>
-        public static int FindLeadingAnchor(RegexTree tree)
+        /// <summary>Computes the leading anchor of a node.</summary>
+        public static RegexNodeKind FindLeadingAnchor(RegexNode node) =>
+            FindLeadingOrTrailingAnchor(node, leading: true);
+
+        /// <summary>Computes the leading anchor of a node.</summary>
+        public static RegexNodeKind FindTrailingAnchor(RegexNode node) =>
+            FindLeadingOrTrailingAnchor(node, leading: false);
+
+        /// <summary>Computes the leading or trailing anchor of a node.</summary>
+        private static RegexNodeKind FindLeadingOrTrailingAnchor(RegexNode node, bool leading)
         {
-            RegexNode curNode = tree.Root;
-            RegexNode? concatNode = null;
-            int nextChild = 0;
+            if (!StackHelper.TryEnsureSufficientExecutionStack())
+            {
+                // We only recur for alternations, but with a really deep nesting of alternations we could potentially overflow.
+                // In such a case, simply stop searching for an anchor.
+                return RegexNodeKind.Unknown;
+            }
 
             while (true)
             {
-                switch (curNode.Kind)
+                switch (node.Kind)
                 {
                     case RegexNodeKind.Bol:
-                        return Bol;
-
                     case RegexNodeKind.Eol:
-                        return Eol;
-
-                    case RegexNodeKind.Boundary:
-                        return Boundary;
-
-                    case RegexNodeKind.ECMABoundary:
-                        return ECMABoundary;
-
                     case RegexNodeKind.Beginning:
-                        return Beginning;
-
                     case RegexNodeKind.Start:
-                        return Start;
-
                     case RegexNodeKind.EndZ:
-                        return EndZ;
-
                     case RegexNodeKind.End:
-                        return End;
+                    case RegexNodeKind.Boundary:
+                    case RegexNodeKind.ECMABoundary:
+                        // Return any anchor found.
+                        return node.Kind;
+
+                    case RegexNodeKind.Atomic:
+                    case RegexNodeKind.Capture:
+                        // For groups, continue exploring the sole child.
+                        node = node.Child(0);
+                        continue;
 
                     case RegexNodeKind.Concatenate:
-                        if (curNode.ChildCount() > 0)
+                        // For concatenations, we expect primarily to explore its first (for leading) or last (for trailing) child,
+                        // but we can also skip over certain kinds of nodes (e.g. Empty), and thus iterate through its children backward
+                        // looking for the last we shouldn't skip.
                         {
-                            concatNode = curNode;
-                            nextChild = 0;
+                            int childCount = node.ChildCount();
+                            RegexNode? child = null;
+                            if (leading)
+                            {
+                                for (int i = 0; i < childCount; i++)
+                                {
+                                    if (node.Child(i).Kind is not (RegexNodeKind.Empty or RegexNodeKind.PositiveLookaround or RegexNodeKind.NegativeLookaround))
+                                    {
+                                        child = node.Child(i);
+                                        break;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                for (int i = childCount - 1; i >= 0; i--)
+                                {
+                                    if (node.Child(i).Kind is not (RegexNodeKind.Empty or RegexNodeKind.PositiveLookaround or RegexNodeKind.NegativeLookaround))
+                                    {
+                                        child = node.Child(i);
+                                        break;
+                                    }
+                                }
+                            }
+
+                            if (child is not null)
+                            {
+                                node = child;
+                                continue;
+                            }
+
+                            goto default;
                         }
-                        break;
 
-                    case RegexNodeKind.Atomic:
-                    case RegexNodeKind.Capture:
-                        curNode = curNode.Child(0);
-                        concatNode = null;
-                        continue;
+                    case RegexNodeKind.Alternate:
+                        // For alternations, every branch needs to lead or trail with the same anchor.
+                        {
+                            // Get the leading/trailing anchor of the first branch.  If there isn't one, bail.
+                            RegexNodeKind anchor = FindLeadingOrTrailingAnchor(node.Child(0), leading);
+                            if (anchor == RegexNodeKind.Unknown)
+                            {
+                                return RegexNodeKind.Unknown;
+                            }
 
-                    case RegexNodeKind.Empty:
-                    case RegexNodeKind.PositiveLookaround:
-                    case RegexNodeKind.NegativeLookaround:
-                        break;
+                            // Look at each subsequent branch and validate it has the same leading or trailing
+                            // anchor.  If any doesn't, bail.
+                            int childCount = node.ChildCount();
+                            for (int i = 1; i < childCount; i++)
+                            {
+                                if (FindLeadingOrTrailingAnchor(node.Child(i), leading) != anchor)
+                                {
+                                    return RegexNodeKind.Unknown;
+                                }
+                            }
 
-                    default:
-                        return 0;
-                }
+                            // All branches have the same leading/trailing anchor.  Return it.
+                            return anchor;
+                        }
 
-                if (concatNode == null || nextChild >= concatNode.ChildCount())
-                {
-                    return 0;
+                    default:
+                        // For everything else, we couldn't find an anchor.
+                        return RegexNodeKind.Unknown;
                 }
-
-                curNode = concatNode.Child(nextChild++);
             }
         }
 
-#if DEBUG
-        [ExcludeFromCodeCoverage]
-        public static string AnchorDescription(int anchors)
-        {
-            var sb = new StringBuilder();
-
-            if ((anchors & Beginning) != 0) sb.Append(", Beginning");
-            if ((anchors & Start) != 0) sb.Append(", Start");
-            if ((anchors & Bol) != 0) sb.Append(", Bol");
-            if ((anchors & Boundary) != 0) sb.Append(", Boundary");
-            if ((anchors & ECMABoundary) != 0) sb.Append(", ECMABoundary");
-            if ((anchors & Eol) != 0) sb.Append(", Eol");
-            if ((anchors & End) != 0) sb.Append(", End");
-            if ((anchors & EndZ) != 0) sb.Append(", EndZ");
-
-            return sb.Length >= 2 ?
-                sb.ToString(2, sb.Length - 2) :
-                "None";
-        }
-#endif
-
         /// <summary>
         /// To avoid recursion, we use a simple integer stack.
         /// </summary>
diff --git a/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs b/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
index 005e9b27bb203a..e3e466dd64ece3 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
@@ -284,8 +284,42 @@ public static IEnumerable<object[]> Match_MemberData()
                 // Using beginning/end of string chars \A, \Z: Actual - "\\Aaaa\\w+zzz\\Z"
                 yield return (@"\Aaaa\w+zzz\Z", "aaaasdfajsdlfjzzza", RegexOptions.None, 0, 18, false, string.Empty);
 
+                // Anchors
+                foreach (RegexOptions anchorOptions in new[] { RegexOptions.None, RegexOptions.Multiline })
+                {
+                    yield return (@"^abc", "abc", anchorOptions, 0, 3, true, "abc");
+                    yield return (@"^abc", " abc", anchorOptions, 0, 4, false, "");
+                    yield return (@"^abc|^def", "def", anchorOptions, 0, 3, true, "def");
+                    yield return (@"^abc|^def", " abc", anchorOptions, 0, 4, false, "");
+                    yield return (@"^abc|^def", " def", anchorOptions, 0, 4, false, "");
+                    yield return (@"abc|^def", " abc", anchorOptions, 0, 4, true, "abc");
+                    yield return (@"abc|^def|^efg", " abc", anchorOptions, 0, 4, true, "abc");
+                    yield return (@"^abc|def|^efg", " def", anchorOptions, 0, 4, true, "def");
+                    yield return (@"^abc|def", " def", anchorOptions, 0, 4, true, "def");
+                    yield return (@"abcd$", "1234567890abcd", anchorOptions, 0, 14, true, "abcd");
+                    yield return (@"abc{1,4}d$", "1234567890abcd", anchorOptions, 0, 14, true, "abcd");
+                    yield return (@"abc{1,4}d$", "1234567890abccccd", anchorOptions, 0, 17, true, "abccccd");
+                }
+                if (!RegexHelpers.IsNonBacktracking(engine))
+                {
+                    yield return (@"\Gabc", "abc", RegexOptions.None, 0, 3, true, "abc");
+                    yield return (@"\Gabc", " abc", RegexOptions.None, 0, 4, false, "");
+                    yield return (@"\Gabc", " abc", RegexOptions.None, 1, 3, true, "abc");
+                    yield return (@"\Gabc|\Gdef", "def", RegexOptions.None, 0, 3, true, "def");
+                    yield return (@"\Gabc|\Gdef", " abc", RegexOptions.None, 0, 4, false, "");
+                    yield return (@"\Gabc|\Gdef", " def", RegexOptions.None, 0, 4, false, "");
+                    yield return (@"\Gabc|\Gdef", " abc", RegexOptions.None, 1, 3, true, "abc");
+                    yield return (@"\Gabc|\Gdef", " def", RegexOptions.None, 1, 3, true, "def");
+                    yield return (@"abc|\Gdef", " abc", RegexOptions.None, 0, 4, true, "abc");
+                    yield return (@"\Gabc|def", " def", RegexOptions.None, 0, 4, true, "def");
+                }
+
                 // Anchors and multiline
-                yield return (@"^A$", "ABC\n", RegexOptions.Multiline, 0, 2, false, string.Empty);
+                yield return (@"^A$", "A\n", RegexOptions.Multiline, 0, 2, true, "A");
+                yield return (@"^A$", "ABC\n", RegexOptions.Multiline, 0, 4, false, string.Empty);
+                yield return (@"^A$", "123\nA", RegexOptions.Multiline, 0, 5, true, "A");
+                yield return (@"^A$", "123\nA\n456", RegexOptions.Multiline, 0, 9, true, "A");
+                yield return (@"^A$|^B$", "123\nB\n456", RegexOptions.Multiline, 0, 9, true, "B");
 
                 // Using beginning/end of string chars \A, \Z: Actual - "\\Aaaa\\w+zzz\\Z"
                 yield return (@"\A(line2\n)line3\Z", "line2\nline3\n", RegexOptions.Multiline, 0, 12, true, "line2\nline3");
@@ -905,7 +939,7 @@ private async Task Match_TestThatTimeoutHappens(RegexEngine engine)
             }
             string input = new string(chars);
 
-            Regex re = await RegexHelpers.GetRegexAsync(engine, @"a.{20}$", RegexOptions.None, TimeSpan.FromMilliseconds(10));
+            Regex re = await RegexHelpers.GetRegexAsync(engine, @"a.{20}^", RegexOptions.None, TimeSpan.FromMilliseconds(10));
             Assert.Throws<RegexMatchTimeoutException>(() => { re.Match(input); });
         }
 
diff --git a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
index 38cf72a3f52380..65ef818124a425 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
@@ -18,6 +18,8 @@ public class RegexReductionTests
         private static readonly FieldInfo s_regexCode;
         private static readonly FieldInfo s_regexCodeCodes;
         private static readonly FieldInfo s_regexCodeTree;
+        private static readonly FieldInfo s_regexCodeFindOptimizations;
+        private static readonly PropertyInfo s_regexCodeFindOptimizationsMaxPossibleLength;
         private static readonly FieldInfo s_regexCodeTreeMinRequiredLength;
 
         static RegexReductionTests()
@@ -31,6 +33,12 @@ static RegexReductionTests()
             s_regexCode = typeof(Regex).GetField("_code", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
             Assert.NotNull(s_regexCode);
 
+            s_regexCodeFindOptimizations = s_regexCode.FieldType.GetField("FindOptimizations", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(s_regexCodeFindOptimizations);
+
+            s_regexCodeFindOptimizationsMaxPossibleLength = s_regexCodeFindOptimizations.FieldType.GetProperty("MaxPossibleLength", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(s_regexCodeFindOptimizationsMaxPossibleLength);
+
             s_regexCodeCodes = s_regexCode.FieldType.GetField("Codes", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
             Assert.NotNull(s_regexCodeCodes);
 
@@ -71,6 +79,20 @@ private static int GetMinRequiredLength(Regex r)
             return (int)minRequiredLength;
         }
 
+        private static int? GetMaxPossibleLength(Regex r)
+        {
+            object code = s_regexCode.GetValue(r);
+            Assert.NotNull(code);
+
+            object findOpts = s_regexCodeFindOptimizations.GetValue(code);
+            Assert.NotNull(findOpts);
+
+            object maxPossibleLength = s_regexCodeFindOptimizationsMaxPossibleLength.GetValue(findOpts);
+            Assert.True(maxPossibleLength is null || maxPossibleLength is int);
+
+            return (int?)maxPossibleLength;
+        }
+
         [Theory]
         [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Many of these optimizations don't exist in .NET Framework.")]
         // Two greedy one loops
@@ -535,70 +557,100 @@ public void PatternsReduceDifferently(string pattern1, string pattern2)
 
         [Theory]
         [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Not computed in netfx")]
-        [InlineData(@"a", 1)]
-        [InlineData(@"[^a]", 1)]
-        [InlineData(@"[abcdefg]", 1)]
-        [InlineData(@"abcd", 4)]
-        [InlineData(@"a*", 0)]
-        [InlineData(@"a*?", 0)]
-        [InlineData(@"a?", 0)]
-        [InlineData(@"a??", 0)]
-        [InlineData(@"a+", 1)]
-        [InlineData(@"a+?", 1)]
-        [InlineData(@"a{2}", 2)]
-        [InlineData(@"a{2}?", 2)]
-        [InlineData(@"a{3,17}", 3)]
-        [InlineData(@"a{3,17}?", 3)]
-        [InlineData(@"(abcd){5}", 20)]
-        [InlineData(@"(abcd|ef){2,6}", 4)]
-        [InlineData(@"abcef|de", 2)]
-        [InlineData(@"abc(def|ghij)k", 7)]
-        [InlineData(@"\d{1,2}-\d{1,2}-\d{2,4}", 6)]
-        [InlineData(@"1(?=9)\d", 2)]
-        [InlineData(@"1(?!\d)\w", 2)]
-        [InlineData(@"a*a*a*a*a*a*a*b*", 0)]
-        [InlineData(@"((a{1,2}){4}){3,7}", 12)]
-        [InlineData(@"\b\w{4}\b", 4)]
-        [InlineData(@"abcd(?=efgh)efgh", 8)]
-        [InlineData(@"abcd(?<=cd)efgh", 8)]
-        [InlineData(@"abcd(?!ab)efgh", 8)]
-        [InlineData(@"abcd(?<!ef)efgh", 8)]
-        [InlineData(@"(a{1073741824}){2}", 2147483647)]
-        [InlineData(@"a{1073741824}b{1073741824}", 2147483647)]
-        [InlineData(@"((((((((((((((((((((((((((((((ab|cd+)|ef+)|gh+)|ij+)|kl+)|mn+)|op+)|qr+)|st+)|uv+)|wx+)|yz+)|01+)|23+)|45+)|67+)|89+)|AB+)|CD+)|EF+)|GH+)|IJ+)|KL+)|MN+)|OP+)|QR+)|ST+)|UV+)|WX+)|YZ)", 2)]
-        [InlineData(@"(YZ+|(WX+|(UV+|(ST+|(QR+|(OP+|(MN+|(KL+|(IJ+|(GH+|(EF+|(CD+|(AB+|(89+|(67+|(45+|(23+|(01+|(yz+|(wx+|(uv+|(st+|(qr+|(op+|(mn+|(kl+|(ij+|(gh+|(ef+|(de+|(a|bc+)))))))))))))))))))))))))))))))", 1)]
-        [InlineData(@"a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(ab|cd+)|ef+)|gh+)|ij+)|kl+)|mn+)|op+)|qr+)|st+)|uv+)|wx+)|yz+)|01+)|23+)|45+)|67+)|89+)|AB+)|CD+)|EF+)|GH+)|IJ+)|KL+)|MN+)|OP+)|QR+)|ST+)|UV+)|WX+)|YZ+)", 3)]
-        [InlineData(@"(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((a)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))", 1)]
-        [InlineData(@"(?(\d)\d{3}|\d)", 1)]
-        [InlineData(@"(?(\d{7})\d{3}|\d{2})", 2)]
-        [InlineData(@"(?(\d{7})\d{2}|\d{3})", 2)]
-        [InlineData(@"(?(\d)\d{3}|\d{2})", 2)]
-        [InlineData(@"(?(\d)|\d{2})", 0)]
-        [InlineData(@"(?(\d)\d{3})", 0)]
-        [InlineData(@"(abc)(?(1)\d{3}|\d{2})", 5)]
-        [InlineData(@"(abc)(?(1)\d{2}|\d{3})", 5)]
-        [InlineData(@"(abc)(?(1)|\d{2})", 3)]
-        [InlineData(@"(abc)(?(1)\d{3})", 3)]
-        [InlineData(@"(abc|)", 0)]
-        [InlineData(@"(|abc)", 0)]
-        [InlineData(@"(?(x)abc|)", 0)]
-        [InlineData(@"(?(x)|abc)", 0)]
-        public void MinRequiredLengthIsCorrect(string pattern, int expectedLength)
+        [InlineData(@"a", RegexOptions.None, 1, 1)]
+        [InlineData(@"[^a]", RegexOptions.None, 1, 1)]
+        [InlineData(@"[abcdefg]", RegexOptions.None, 1, 1)]
+        [InlineData(@"abcd", RegexOptions.None, 4, 4)]
+        [InlineData(@"a*", RegexOptions.None, 0, null)]
+        [InlineData(@"a*?", RegexOptions.None, 0, null)]
+        [InlineData(@"a?", RegexOptions.None, 0, 1)]
+        [InlineData(@"a??", RegexOptions.None, 0, 1)]
+        [InlineData(@"a+", RegexOptions.None, 1, null)]
+        [InlineData(@"a+?", RegexOptions.None, 1, null)]
+        [InlineData(@"a{2}", RegexOptions.None, 2, 2)]
+        [InlineData(@"a{2}?", RegexOptions.None, 2, 2)]
+        [InlineData(@"a{3,17}", RegexOptions.None, 3, 17)]
+        [InlineData(@"a{3,17}?", RegexOptions.None, 3, 17)]
+        [InlineData(@"[^a]{3,17}", RegexOptions.None, 3, 17)]
+        [InlineData(@"[^a]{3,17}?", RegexOptions.None, 3, 17)]
+        [InlineData(@"(abcd){5}", RegexOptions.None, 20, 20)]
+        [InlineData(@"(abcd|ef){2,6}", RegexOptions.None, 4, 24)]
+        [InlineData(@"abcef|de", RegexOptions.None, 2, 5)]
+        [InlineData(@"abc(def|ghij)k", RegexOptions.None, 7, 8)]
+        [InlineData(@"abc(def|ghij|k||lmnopqrs|t)u", RegexOptions.None, 4, 12)]
+        [InlineData(@"(ab)c(def|ghij|k|l|\1|m)n", RegexOptions.None, 4, null)]
+        [InlineData(@"abc|de*f|ghi", RegexOptions.None, 2, null)]
+        [InlineData(@"abc|de+f|ghi", RegexOptions.None, 3, null)]
+        [InlineData(@"abc|(def)+|ghi", RegexOptions.None, 3, null)]
+        [InlineData(@"(abc)+|def", RegexOptions.None, 3, null)]
+        [InlineData(@"\d{1,2}-\d{1,2}-\d{2,4}", RegexOptions.None, 6, 10)]
+        [InlineData(@"\d{1,2}-(?>\d{1,2})-\d{2,4}", RegexOptions.None, 6, 10)]
+        [InlineData(@"1(?=9)\d", RegexOptions.None, 2, 2)]
+        [InlineData(@"1(?!\d)\w", RegexOptions.None, 2, 2)]
+        [InlineData(@"a*a*a*a*a*a*a*b*", RegexOptions.None, 0, null)]
+        [InlineData(@"((a{1,2}){4}){3,7}", RegexOptions.None, 12, 56)]
+        [InlineData(@"((a{1,2}){4}?){3,7}", RegexOptions.None, 12, 56)]
+        [InlineData(@"\b\w{4}\b", RegexOptions.None, 4, 4)]
+        [InlineData(@"\b\w{4}\b", RegexOptions.ECMAScript,  4, 4)]
+        [InlineData(@"abcd(?=efgh)efgh", RegexOptions.None, 8, 8)]
+        [InlineData(@"abcd(?<=cd)efgh", RegexOptions.None, 8, 8)]
+        [InlineData(@"abcd(?!ab)efgh", RegexOptions.None, 8, 8)]
+        [InlineData(@"abcd(?<!ef)efgh", RegexOptions.None, 8, 8)]
+        [InlineData(@"(a{1073741824}){2}", RegexOptions.None, 2147483646, null)] // min length max is bound to int.MaxValue - 1 for convenience in other places where we need to be able to add 1 without risk of overflow
+        [InlineData(@"a{1073741824}b{1073741824}", RegexOptions.None, 2147483646, null)]
+        [InlineData(@"((((((((((((((((((((((((((((((ab|cd+)|ef+)|gh+)|ij+)|kl+)|mn+)|op+)|qr+)|st+)|uv+)|wx+)|yz+)|01+)|23+)|45+)|67+)|89+)|AB+)|CD+)|EF+)|GH+)|IJ+)|KL+)|MN+)|OP+)|QR+)|ST+)|UV+)|WX+)|YZ)", RegexOptions.None, 2, null)]
+        [InlineData(@"(YZ+|(WX+|(UV+|(ST+|(QR+|(OP+|(MN+|(KL+|(IJ+|(GH+|(EF+|(CD+|(AB+|(89+|(67+|(45+|(23+|(01+|(yz+|(wx+|(uv+|(st+|(qr+|(op+|(mn+|(kl+|(ij+|(gh+|(ef+|(de+|(a|bc+)))))))))))))))))))))))))))))))", RegexOptions.None, 1, null)]
+        [InlineData(@"a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(ab|cd+)|ef+)|gh+)|ij+)|kl+)|mn+)|op+)|qr+)|st+)|uv+)|wx+)|yz+)|01+)|23+)|45+)|67+)|89+)|AB+)|CD+)|EF+)|GH+)|IJ+)|KL+)|MN+)|OP+)|QR+)|ST+)|UV+)|WX+)|YZ+)", RegexOptions.None, 3, null)]
+        [InlineData(@"(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((a)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))", RegexOptions.None, 1, 1)]
+        [InlineData(@"(?(\d)\d{3}|\d)", RegexOptions.None, 1, 3)]
+        [InlineData(@"(?(\d{7})\d{3}|\d{2})", RegexOptions.None, 2, 3)]
+        [InlineData(@"(?(\d{7})\d{2}|\d{3})", RegexOptions.None, 2, 3)]
+        [InlineData(@"(?(\d)\d{3}|\d{2})", RegexOptions.None, 2, 3)]
+        [InlineData(@"(?(\d)|\d{2})", RegexOptions.None, 0, 2)]
+        [InlineData(@"(?(\d)\d{3})", RegexOptions.None, 0, 3)]
+        [InlineData(@"(abc)(?(1)\d{3}|\d{2})", RegexOptions.None, 5, 6)]
+        [InlineData(@"(abc)(?(1)\d{2}|\d{3})", RegexOptions.None, 5, 6)]
+        [InlineData(@"(abc)(?(1)|\d{2})", RegexOptions.None, 3, 5)]
+        [InlineData(@"(abc)(?(1)\d{3})", RegexOptions.None, 3, 6)]
+        [InlineData(@"(abc|)", RegexOptions.None, 0, 3)]
+        [InlineData(@"(|abc)", RegexOptions.None, 0, 3)]
+        [InlineData(@"(?(x)abc|)", RegexOptions.None, 0, 3)]
+        [InlineData(@"(?(x)|abc)", RegexOptions.None, 0, 3)]
+        [InlineData(@"(?(x)|abc)^\A\G\z\Z$", RegexOptions.None, 0, 3)]
+        [InlineData(@"(?(x)|abc)^\A\G\z$\Z", RegexOptions.Multiline, 0, 3)]
+        [InlineData(@"^\A\Gabc", RegexOptions.None, 3, null)] // leading anchor currently prevents ComputeMaxLength from being invoked, as it's not needed
+        [InlineData(@"^\A\Gabc", RegexOptions.Multiline, 3, null)]
+        [InlineData(@"abc            def", RegexOptions.IgnorePatternWhitespace, 6, 6)]
+        [InlineData(@"abcdef", RegexOptions.RightToLeft, 6, null)]
+        public void MinMaxLengthIsCorrect(string pattern, RegexOptions options, int expectedMin, int? expectedMax)
         {
-            var r = new Regex(pattern);
-            Assert.Equal(expectedLength, GetMinRequiredLength(r));
+            var r = new Regex(pattern, options);
+            Assert.Equal(expectedMin, GetMinRequiredLength(r));
+            if (!pattern.EndsWith("$", StringComparison.Ordinal) &&
+                !pattern.EndsWith(@"\Z", StringComparison.OrdinalIgnoreCase))
+            {
+                // MaxPossibleLength is currently only computed/stored if there's a trailing End{Z} anchor as the max length is otherwise unused
+                r = new Regex($"(?:{pattern})$", options);
+            }
+            Assert.Equal(expectedMax, GetMaxPossibleLength(r));
         }
 
         [Fact]
         [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Not computed in netfx")]
-        public void MinRequiredLengthIsCorrect_HugeDepth()
+        public void MinMaxLengthIsCorrect_HugeDepth()
         {
             const int Depth = 10_000;
-            var r = new Regex($"{new string('(', Depth)}a{new string(')', Depth)}"); // too deep for analysis on some platform default stack sizes
+            var r = new Regex($"{new string('(', Depth)}a{new string(')', Depth)}$"); // too deep for analysis on some platform default stack sizes
+
             int minRequiredLength = GetMinRequiredLength(r);
             Assert.True(
                 minRequiredLength == 1 /* successfully analyzed */ || minRequiredLength == 0 /* ran out of stack space to complete analysis */,
                 $"Expected 1 or 0, got {minRequiredLength}");
+
+            int? maxPossibleLength = GetMaxPossibleLength(r);
+            Assert.True(
+                maxPossibleLength == 1 /* successfully analyzed */ || maxPossibleLength is null /* ran out of stack space to complete analysis */,
+                $"Expected 1 or null, got {maxPossibleLength}");
         }
     }
 }

From 24bd6679fb19515fd278ddc6c404eb647bb9bef5 Mon Sep 17 00:00:00 2001
From: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date: Tue, 25 Jan 2022 17:35:28 +0300
Subject: [PATCH 057/161] Add the exception set for `ObjGetType` (#64106)

* Model NRE for ObjGetType

* Add tests
---
 src/coreclr/jit/gentree.cpp                   | 18 +++------
 src/coreclr/jit/namedintrinsiclist.h          |  5 ++-
 src/coreclr/jit/valuenum.cpp                  |  3 +-
 .../JIT/opt/ValueNumbering/ExceptionSets.cs   | 37 +++++++++++++++++++
 .../opt/ValueNumbering/ExceptionSets.csproj   | 13 +++++++
 5 files changed, 61 insertions(+), 15 deletions(-)
 create mode 100644 src/tests/JIT/opt/ValueNumbering/ExceptionSets.cs
 create mode 100644 src/tests/JIT/opt/ValueNumbering/ExceptionSets.csproj

diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index 8c9450cfbf5649..68a7b49d74dbb4 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -5226,7 +5226,7 @@ bool GenTree::OperRequiresCallFlag(Compiler* comp)
 // Return Value:
 //    True if the given node contains an implicit indirection
 //
-// Note that for the GT_HWINTRINSIC node we have to examine the
+// Note that for the [HW]INTRINSIC nodes we have to examine the
 // details of the node to determine its result.
 //
 
@@ -5250,6 +5250,8 @@ bool GenTree::OperIsImplicitIndir() const
         case GT_ARR_ELEM:
         case GT_ARR_OFFSET:
             return true;
+        case GT_INTRINSIC:
+            return AsIntrinsic()->gtIntrinsicName == NI_System_Object_GetType;
 #ifdef FEATURE_SIMD
         case GT_SIMD:
         {
@@ -5306,18 +5308,8 @@ bool GenTree::OperMayThrow(Compiler* comp)
 
         case GT_INTRINSIC:
             // If this is an intrinsic that represents the object.GetType(), it can throw an NullReferenceException.
-            // Report it as may throw.
-            // Note: Some of the rest of the existing intrinsics could potentially throw an exception (for example
-            //       the array and string element access ones). They are handled differently than the GetType intrinsic
-            //       and are not marked with GTF_EXCEPT. If these are revisited at some point to be marked as
-            //       GTF_EXCEPT,
-            //       the code below might need to be specialized to handle them properly.
-            if ((this->gtFlags & GTF_EXCEPT) != 0)
-            {
-                return true;
-            }
-
-            break;
+            // Currently, this is the only intrinsic that can throw an exception.
+            return AsIntrinsic()->gtIntrinsicName == NI_System_Object_GetType;
 
         case GT_CALL:
 
diff --git a/src/coreclr/jit/namedintrinsiclist.h b/src/coreclr/jit/namedintrinsiclist.h
index 7b2108d3edd057..68ea721ae48180 100644
--- a/src/coreclr/jit/namedintrinsiclist.h
+++ b/src/coreclr/jit/namedintrinsiclist.h
@@ -4,7 +4,10 @@
 #ifndef _NAMEDINTRINSICLIST_H_
 #define _NAMEDINTRINSICLIST_H_
 
-// Named jit intrinsics
+// Named jit intrinsics.
+
+// When adding a new intrinsic that will use the GT_INTRINSIC node and can throw, make sure
+// to update the "OperMayThrow" and "fgValueNumberAddExceptionSet" methods to account for that.
 
 enum NamedIntrinsic : unsigned short
 {
diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp
index 356124ab00e5cb..3faa6efc7ace9b 100644
--- a/src/coreclr/jit/valuenum.cpp
+++ b/src/coreclr/jit/valuenum.cpp
@@ -10992,7 +10992,8 @@ void Compiler::fgValueNumberAddExceptionSet(GenTree* tree)
                 break;
 
             case GT_INTRINSIC:
-                // ToDo: model the exceptions for Intrinsics
+                assert(tree->AsIntrinsic()->gtIntrinsicName == NI_System_Object_GetType);
+                fgValueNumberAddExceptionSetForIndirection(tree, tree->AsIntrinsic()->gtGetOp1());
                 break;
 
             case GT_IND:
diff --git a/src/tests/JIT/opt/ValueNumbering/ExceptionSets.cs b/src/tests/JIT/opt/ValueNumbering/ExceptionSets.cs
new file mode 100644
index 00000000000000..6a413303ad194c
--- /dev/null
+++ b/src/tests/JIT/opt/ValueNumbering/ExceptionSets.cs
@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable CS0253 // Possible unintended reference comparison
+
+class ExceptionSets
+{
+    public static int Main()
+    {
+        try
+        {
+            TestObjGetType(null, 0);
+            return 101;
+        }
+        catch (NullReferenceException) { }
+
+        return 100;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static bool TestObjGetType(object a, int i)
+    {
+        var fls = false;
+        var c1 = i == 0;
+        var c2 = c1;
+
+        if (((a.GetType() == a) & fls) | (i == 0))
+        {
+            return true;
+        }
+
+        return c2;
+    }
+}
diff --git a/src/tests/JIT/opt/ValueNumbering/ExceptionSets.csproj b/src/tests/JIT/opt/ValueNumbering/ExceptionSets.csproj
new file mode 100644
index 00000000000000..5d8fe225297649
--- /dev/null
+++ b/src/tests/JIT/opt/ValueNumbering/ExceptionSets.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <CLRTestPriority>1</CLRTestPriority>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+</Project>

From 902db7e364422b9918d3d9d4ee2c1e6362359cf7 Mon Sep 17 00:00:00 2001
From: Jan Kotas <jkotas@microsoft.com>
Date: Tue, 25 Jan 2022 06:37:01 -0800
Subject: [PATCH 058/161] [ILVerify] Fix casting check for arrays of generic
 parameters with class constraints (#64259)

Fixes #63999
---
 .../Common/TypeSystem/Common/CastingHelper.cs | 28 +++++++++++++++++--
 .../CastingTests.cs                           | 15 ++++++++++
 .../CoreTestAssembly/Casting.cs               |  4 +++
 3 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/src/coreclr/tools/Common/TypeSystem/Common/CastingHelper.cs b/src/coreclr/tools/Common/TypeSystem/Common/CastingHelper.cs
index 1b067af21b476a..03a59a840e1ded 100644
--- a/src/coreclr/tools/Common/TypeSystem/Common/CastingHelper.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Common/CastingHelper.cs
@@ -263,7 +263,7 @@ private static bool CanCastParamTo(this ParameterizedType thisType, TypeDesc par
             else if (curTypesParm.IsGenericParameter)
             {
                 var genericVariableFromParam = (GenericParameterDesc)curTypesParm;
-                if (genericVariableFromParam.HasReferenceTypeConstraint)
+                if (genericVariableFromParam.HasReferenceTypeConstraint || IsConstrainedAsGCPointer(genericVariableFromParam))
                 {
                     return genericVariableFromParam.CanCastToInternal(paramType, protect);
                 }
@@ -281,6 +281,30 @@ private static bool CanCastParamTo(this ParameterizedType thisType, TypeDesc par
             return false;
         }
 
+        private static bool IsConstrainedAsGCPointer(GenericParameterDesc type)
+        {
+            foreach (var typeConstraint in type.TypeConstraints)
+            {
+                if (typeConstraint.IsGenericParameter)
+                {
+                    if (IsConstrainedAsGCPointer((GenericParameterDesc)typeConstraint))
+                        return true;
+                }
+
+                if (!typeConstraint.IsInterface && typeConstraint.IsGCPointer)
+                {
+                    // Object, ValueType, and Enum are GCPointers but they do not constrain the type to GCPointer!
+                    if (!typeConstraint.IsWellKnownType(WellKnownType.Object) &&
+                        !typeConstraint.IsWellKnownType(WellKnownType.ValueType) &&
+                        !typeConstraint.IsWellKnownType(WellKnownType.Enum))
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
         private static TypeFlags GetNormalizedIntegralArrayElementType(TypeDesc type)
         {
             Debug.Assert(!type.IsEnum);
@@ -502,7 +526,7 @@ private static bool IsBoxedAndCanCastTo(this TypeDesc thisType, TypeDesc otherTy
             else if (thisType.IsGenericParameter)
             {
                 var genericVariableFromParam = (GenericParameterDesc)thisType;
-                if (genericVariableFromParam.HasReferenceTypeConstraint)
+                if (genericVariableFromParam.HasReferenceTypeConstraint || IsConstrainedAsGCPointer(genericVariableFromParam))
                 {
                     return genericVariableFromParam.CanCastToInternal(otherType, protect);
                 }
diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CastingTests.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CastingTests.cs
index f6cd2e187d46c5..4bcf3432f522f3 100644
--- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CastingTests.cs
+++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CastingTests.cs
@@ -202,6 +202,21 @@ public void TestNullableCasting()
             Assert.True(intType.CanCastTo(nullableOfIntType));
         }
 
+        [Fact]
+        public void TestGenericParameterArrayCasting()
+        {
+            TypeDesc baseArrayType = _testModule.GetType("Casting", "Base").MakeArrayType();
+            TypeDesc iFooArrayType = _testModule.GetType("Casting", "IFoo").MakeArrayType();
+
+            TypeDesc paramArrayWithBaseClassConstraint =
+                _testModule.GetType("Casting", "ClassWithBaseClassConstraint`1").Instantiation[0].MakeArrayType();
+            TypeDesc paramArrayWithInterfaceConstraint =
+                _testModule.GetType("Casting", "ClassWithInterfaceConstraint`1").Instantiation[0].MakeArrayType();
+
+            Assert.True(paramArrayWithBaseClassConstraint.CanCastTo(baseArrayType));
+            Assert.False(paramArrayWithInterfaceConstraint.CanCastTo(iFooArrayType));
+        }
+
         [Fact]
         public void TestRecursiveCanCast()
         {
diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Casting.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Casting.cs
index a6ae700e942a1d..03ce4ae4332cdd 100644
--- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Casting.cs
+++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Casting.cs
@@ -3,6 +3,8 @@
 
 namespace Casting
 {
+    class Base { }
+
     interface IFoo { }
 
     interface IContravariant<in T> { }
@@ -21,6 +23,8 @@ class ClassWithNoConstraint<T> { }
 
     class ClassWithValueTypeConstraint<T> where T : struct { }
 
+    class ClassWithBaseClassConstraint<T> where T : Base { }
+
     class ClassWithInterfaceConstraint<T> where T : IFoo { }
 
     class ClassWithRecursiveImplementation : IContravariant<IContravariant<ClassWithRecursiveImplementation>> { }

From 802dc689fdcca6e52e17604048465a50203371b1 Mon Sep 17 00:00:00 2001
From: Koundinya Veluri <kouvel@users.noreply.github.com>
Date: Tue, 25 Jan 2022 06:47:22 -0800
Subject: [PATCH 059/161] Use lower call count threshold for tiering in debug
 builds (#60945)

* Use lower call count threshold for tiering in debug builds

To exercise more paths during tests, see https://github.com/dotnet/runtime/pull/60886
---
 src/coreclr/inc/clrconfigvalues.h | 33 ++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/src/coreclr/inc/clrconfigvalues.h b/src/coreclr/inc/clrconfigvalues.h
index 28b1010666369f..e1edb2466e65c8 100644
--- a/src/coreclr/inc/clrconfigvalues.h
+++ b/src/coreclr/inc/clrconfigvalues.h
@@ -562,21 +562,36 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_HillClimbing_GainExponent,
 /// Tiered Compilation
 ///
 #ifdef FEATURE_TIERED_COMPILATION
+#ifdef _DEBUG
+// Use lower values to exercise more paths sooner
+#define TC_BackgroundWorkerTimeoutMs (100)
+#define TC_CallCountThreshold (2)
+#define TC_CallCountingDelayMs (1)
+#define TC_DelaySingleProcMultiplier (2)
+#define TC_DeleteCallCountingStubsAfter (1)
+#else // !_DEBUG
+#define TC_BackgroundWorkerTimeoutMs (4000)
+#define TC_CallCountThreshold (30)
+#define TC_CallCountingDelayMs (100)
+#define TC_DelaySingleProcMultiplier (10)
+#define TC_DeleteCallCountingStubsAfter (4096)
+#endif // _DEBUG
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_TieredCompilation, W("TieredCompilation"), 1, "Enables tiered compilation")
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_TC_QuickJit, W("TC_QuickJit"), 1, "For methods that would be jitted, enable using quick JIT when appropriate.")
 RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_TC_QuickJitForLoops, W("TC_QuickJitForLoops"), 0, "When quick JIT is enabled, quick JIT may also be used for methods that contain loops.")
 RETAIL_CONFIG_DWORD_INFO(EXTERNAL_TC_AggressiveTiering, W("TC_AggressiveTiering"), 0, "Transition through tiers aggressively.")
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_BackgroundWorkerTimeoutMs, W("TC_BackgroundWorkerTimeoutMs"), 4000, "How long in milliseconds the background worker thread may remain idle before exiting.")
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_CallCountThreshold, W("TC_CallCountThreshold"), 30, "Number of times a method must be called in tier 0 after which it is promoted to the next tier.")
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_CallCountingDelayMs, W("TC_CallCountingDelayMs"), 100, "A perpetual delay in milliseconds that is applied call counting in tier 0 and jitting at higher tiers, while there is startup-like activity.")
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_DelaySingleProcMultiplier, W("TC_DelaySingleProcMultiplier"), 10, "Multiplier for TC_CallCountingDelayMs that is applied on a single-processor machine or when the process is affinitized to a single processor.")
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_BackgroundWorkerTimeoutMs, W("TC_BackgroundWorkerTimeoutMs"), TC_BackgroundWorkerTimeoutMs, "How long in milliseconds the background worker thread may remain idle before exiting.")
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_CallCountThreshold, W("TC_CallCountThreshold"), TC_CallCountThreshold, "Number of times a method must be called in tier 0 after which it is promoted to the next tier.")
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_CallCountingDelayMs, W("TC_CallCountingDelayMs"), TC_CallCountingDelayMs, "A perpetual delay in milliseconds that is applied call counting in tier 0 and jitting at higher tiers, while there is startup-like activity.")
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_DelaySingleProcMultiplier, W("TC_DelaySingleProcMultiplier"), TC_DelaySingleProcMultiplier, "Multiplier for TC_CallCountingDelayMs that is applied on a single-processor machine or when the process is affinitized to a single processor.")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_CallCounting, W("TC_CallCounting"), 1, "Enabled by default (only activates when TieredCompilation is also enabled). If disabled immediately backpatches prestub, and likely prevents any promotion to higher tiers")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_UseCallCountingStubs, W("TC_UseCallCountingStubs"), 1, "Uses call counting stubs for faster call counting.")
-#ifdef _DEBUG
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_DeleteCallCountingStubsAfter, W("TC_DeleteCallCountingStubsAfter"), 1, "Deletes call counting stubs after this many have completed. Zero to disable deleting.")
-#else
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_DeleteCallCountingStubsAfter, W("TC_DeleteCallCountingStubsAfter"), 4096, "Deletes call counting stubs after this many have completed. Zero to disable deleting.")
-#endif
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_TC_DeleteCallCountingStubsAfter, W("TC_DeleteCallCountingStubsAfter"), TC_DeleteCallCountingStubsAfter, "Deletes call counting stubs after this many have completed. Zero to disable deleting.")
+#undef TC_BackgroundWorkerTimeoutMs
+#undef TC_CallCountThreshold
+#undef TC_CallCountingDelayMs
+#undef TC_DelaySingleProcMultiplier
+#undef TC_DeleteCallCountingStubsAfter
 #endif // FEATURE_TIERED_COMPILATION
 
 ///

From d910ce301fad2f8e8a4ff82ec7da658d7852b034 Mon Sep 17 00:00:00 2001
From: Steve Pfister <steveisok@users.noreply.github.com>
Date: Tue, 25 Jan 2022 07:37:06 -0800
Subject: [PATCH 060/161] Skip tests using AsyncIO in
 FileSystemAclExtensionsTests where it's not supported (#64212)

The mono runtime does not yet support AsyncIO on Windows and there were some tests failing on CI because of it.
Fixes #64221
---
 .../tests/FileSystemAclExtensionsTests.cs                   | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs b/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs
index 80eb1805310b5b..5a525cf5f60e38 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs
+++ b/src/libraries/System.IO.FileSystem.AccessControl/tests/FileSystemAclExtensionsTests.cs
@@ -409,7 +409,8 @@ from options in Enum.GetValues<FileOptions>()
             where !(rights == FileSystemRights.CreateFiles &&
                     (mode == FileMode.Append || mode == FileMode.Create || mode == FileMode.CreateNew)) &&
                   !(mode == FileMode.Truncate && rights != FileSystemRights.Write) &&
-                  options != FileOptions.Encrypted // Using FileOptions.Encrypted throws UnauthorizedAccessException when attempting to read the created file
+                  (options != FileOptions.Encrypted && // Using FileOptions.Encrypted throws UnauthorizedAccessException when attempting to read the created file
+                  !(options == FileOptions.Asynchronous && !PlatformDetection.IsAsyncFileIOSupported))// Async IO not supported on Windows using Mono runtime https://github.com/dotnet/runtime/issues/34582
             select new object[] { mode, rights, share, options };
 
         [Theory]
@@ -432,7 +433,8 @@ public static IEnumerable<object[]> ReadRights_AllArguments_Data() =>
             from rights in s_readableRights
             from share in Enum.GetValues<FileShare>()
             from options in Enum.GetValues<FileOptions>()
-            where options != FileOptions.Encrypted // Using FileOptions.Encrypted throws UnauthorizedAccessException when attempting to read the created file
+            where options != FileOptions.Encrypted && // Using FileOptions.Encrypted throws UnauthorizedAccessException when attempting to read the created file
+            !(options == FileOptions.Asynchronous && !PlatformDetection.IsAsyncFileIOSupported) // Async IO not supported on Windows using Mono runtime https://github.com/dotnet/runtime/issues/34582
             select new object[] { mode, rights, share, options };
 
         [Theory]

From 722ecced8963c83c315104513babd78620502db2 Mon Sep 17 00:00:00 2001
From: Steve Harter <steveharter@users.noreply.github.com>
Date: Tue, 25 Jan 2022 10:40:34 -0600
Subject: [PATCH 061/161] Correct JsonNode.Root doc (#64238)

---
 .../System.Text.Json/src/System/Text/Json/Nodes/JsonNode.cs   | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonNode.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonNode.cs
index cfe4a1130db3aa..dc34dcfba82761 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonNode.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonNode.cs
@@ -140,8 +140,10 @@ public string GetPath()
 
         /// <summary>
         ///   Gets the root <see cref="JsonNode"/>.
-        ///   If the current <see cref="JsonNode"/> is a root, <see langword="null"/> is returned.
         /// </summary>
+        /// <remarks>
+        ///   The current node is returned if it is a root.
+        /// </remarks>
         public JsonNode Root
         {
             get

From 233c0644a472d95ac6f0418c2ee3020c1afd4187 Mon Sep 17 00:00:00 2001
From: Jo Shields <directhex@apebox.org>
Date: Tue, 25 Jan 2022 11:50:09 -0500
Subject: [PATCH 062/161] Take ARMv6 out of PlatformGroup All (#64267)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Take ARMv6 out of PlatformGroup All, CoreCLR assumes this means full support

Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>
---
 eng/pipelines/common/platform-matrix.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/pipelines/common/platform-matrix.yml b/eng/pipelines/common/platform-matrix.yml
index 0938ee359b4a47..4f0200380bc9f7 100644
--- a/eng/pipelines/common/platform-matrix.yml
+++ b/eng/pipelines/common/platform-matrix.yml
@@ -53,7 +53,7 @@ jobs:
         ${{ insert }}: ${{ parameters.jobParameters }}
 
 # Linux armv6
-- ${{ if or(containsValue(parameters.platforms, 'Linux_armv6'), in(parameters.platformGroup, 'all', 'gcstress')) }}:
+- ${{ if or(containsValue(parameters.platforms, 'Linux_armv6'), or(and(ne(parameters.runtimeFlavor, 'mono'), in(parameters.platformGroup, 'gcstress')), and(eq(parameters.runtimeFlavor, 'mono'), in(parameters.platformGroup, 'all', 'gcstress')))) }}:
   - template: xplat-setup.yml
     parameters:
       jobTemplate: ${{ parameters.jobTemplate }}

From 74f5ca5a81e03accbaa571018350e781e093acdc Mon Sep 17 00:00:00 2001
From: Jo Shields <directhex@apebox.org>
Date: Tue, 25 Jan 2022 12:52:36 -0500
Subject: [PATCH 063/161] Only send to Helix for rolling build, due to small
 Helix queue (#64274)

---
 eng/pipelines/runtime-staging.yml | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/eng/pipelines/runtime-staging.yml b/eng/pipelines/runtime-staging.yml
index e06a9a6344d9b9..c51d639d29f0f2 100644
--- a/eng/pipelines/runtime-staging.yml
+++ b/eng/pipelines/runtime-staging.yml
@@ -261,18 +261,13 @@ jobs:
           eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
           eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
           eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
-          eq(variables['isManualOrIsNotPR'], true),
-          eq(variables['isFullMatrix'], true))
-      # extra steps, run tests
-      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
-      extraStepsParameters:
-        creator: dotnet-bot
-        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
-        condition: >-
-          or(
-          eq(variables['librariesContainsChange'], true),
-          eq(variables['monoContainsChange'], true),
           eq(variables['isRollingBuild'], true))
+      ${{ if eq(variables['isRollingBuild'], true) }}:
+        # extra steps, run tests
+        extraStepsTemplate: /eng/pipelines/libraries/helix.yml
+        extraStepsParameters:
+          creator: dotnet-bot
+          testRunNamePrefixSuffix: Mono_$(_BuildConfig)
 
 #
 # Build the whole product using Mono and run runtime tests with the JIT.

From aa1b4f8e4a029cea54e2a87c1ff027d5a20e323c Mon Sep 17 00:00:00 2001
From: Aaron Robinson <arobins@microsoft.com>
Date: Tue, 25 Jan 2022 13:15:47 -0500
Subject: [PATCH 064/161] Add ref field runtime feature indication (#64167)

* Add ref field runtime feature indication

Co-authored-by: Stephen Toub <stoub@microsoft.com>
---
 .../src/System/Runtime/CompilerServices/RuntimeFeature.cs   | 6 ++++++
 src/libraries/System.Runtime/ref/System.Runtime.cs          | 1 +
 2 files changed, 7 insertions(+)

diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeFeature.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeFeature.cs
index a94a0e19d01761..9e0a5ed29e42e8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeFeature.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeFeature.cs
@@ -27,6 +27,11 @@ public static partial class RuntimeFeature
         /// </summary>
         public const string CovariantReturnsOfClasses = nameof(CovariantReturnsOfClasses);
 
+        /// <summary>
+        /// Represents a runtime feature where types can define ref fields.
+        /// </summary>
+        public const string ByRefFields = nameof(ByRefFields);
+
         /// <summary>
         /// Indicates that this version of runtime supports virtual static members of interfaces.
         /// </summary>
@@ -42,6 +47,7 @@ public static bool IsSupported(string feature)
             {
                 case PortablePdb:
                 case CovariantReturnsOfClasses:
+                case ByRefFields:
                 case UnmanagedSignatureCallingConvention:
                 case DefaultImplementationsOfInterfaces:
 #pragma warning disable CA2252
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index ea9cc7ecc01808..b8b136aeb3b5a7 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -13209,6 +13209,7 @@ public RuntimeCompatibilityAttribute() { }
     }
     public static partial class RuntimeFeature
     {
+        public const string ByRefFields = "ByRefFields";
         public const string CovariantReturnsOfClasses = "CovariantReturnsOfClasses";
         public const string DefaultImplementationsOfInterfaces = "DefaultImplementationsOfInterfaces";
         public const string PortablePdb = "PortablePdb";

From 442a42147ef23c3b9742abcd8b997e8f472af68a Mon Sep 17 00:00:00 2001
From: Egor Bogatov <egorbo@gmail.com>
Date: Tue, 25 Jan 2022 21:54:35 +0300
Subject: [PATCH 065/161] Faster IndexOf for substrings (#63285)

* Improve "lastChar == firstChar" case, also, use IndexOf directly if value.Length == 1

* Try plain IndexOf first, to optimize cases where even first char of value is never met

* add 1-byte implementation

* copyrights

* fix copy-paste mistake

* Initial LastIndexOf impl

* More efficient LastIndexOf

* fix bug in Char version (we need two clear two lowest bits in the mask) & temporarily remove AdvSimd impl

* use ResetLowestSetBit

* Fix bug

* Add two-byte LastIndexOf

* Fix build

* Minor optimizations

* optimize cases with two-byte/two-char values

* Remove gotos, fix build

* fix bug in LastIndexOf

* Make sure String.LastIndexOf is optimized

* Use xplat simd helpers - implicit ARM support

* fix arm

* Delete \

* Use Vector128.IsHardwareAccelerated

* Fix build

* Use IsAllZero

* Address feedback

* Address feedback

* micro-optimization, do-while is better here since mask is guaranteed to be non-zero

* Address feedabc

* Use clever trick I borrowed from IndexOfAny for trailing elements

* give up on +1 bump for SequenceCompare

* Clean up

* Clean up

* fix build

* Add debug asserts

* Clean up: give up on the unrolled trick - too little value from code bloat

* Add a test

* Fix build

* Add byte-specific test

* Fix build

* Update IndexOfSequence.byte.cs
---
 THIRD-PARTY-NOTICES.TXT                       |  29 ++
 .../tests/Span/IndexOfSequence.byte.cs        | 101 ++++++
 .../tests/Span/IndexOfSequence.char.cs        | 101 ++++++
 .../src/System/MemoryExtensions.cs            |  25 +-
 .../src/System/Numerics/BitOperations.cs      |  20 ++
 .../src/System/SpanHelpers.Byte.cs            | 310 +++++++++++++++---
 .../src/System/SpanHelpers.Char.cs            | 299 ++++++++++++++++-
 .../src/System/SpanHelpers.T.cs               |  10 +-
 8 files changed, 833 insertions(+), 62 deletions(-)

diff --git a/THIRD-PARTY-NOTICES.TXT b/THIRD-PARTY-NOTICES.TXT
index e38f6ef907d430..55329a8b022944 100644
--- a/THIRD-PARTY-NOTICES.TXT
+++ b/THIRD-PARTY-NOTICES.TXT
@@ -697,6 +697,35 @@ License for fastmod (https://github.com/lemire/fastmod) and ibm-fpgen (https://g
    See the License for the specific language governing permissions and
    limitations under the License.
 
+License for sse4-strstr (https://github.com/WojciechMula/sse4-strstr)
+--------------------------------------
+
+   Copyright (c) 2008-2016, Wojciech Muła
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 License notice for The C++ REST SDK
 -----------------------------------
 
diff --git a/src/libraries/System.Memory/tests/Span/IndexOfSequence.byte.cs b/src/libraries/System.Memory/tests/Span/IndexOfSequence.byte.cs
index 33250569da2da8..1a9027d0fc7447 100644
--- a/src/libraries/System.Memory/tests/Span/IndexOfSequence.byte.cs
+++ b/src/libraries/System.Memory/tests/Span/IndexOfSequence.byte.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Xunit;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
 
 namespace System.SpanTests
 {
@@ -115,5 +117,104 @@ public static void IndexOfSequenceLengthOneValueJustPasttVeryEnd_Byte()
             int index = span.IndexOf(value);
             Assert.Equal(-1, index);
         }
+
+        public static IEnumerable<object[]> IndexOfSubSeqData_Byte()
+        {
+            // searchSpace, value, expected IndexOf value, expected LastIndexOf value
+            yield return new object[] { new byte[]{0,0,0,0,0},new byte[]{0,0,0}, 0, 2};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0},new byte[]{0,71,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0},new byte[]{0,0,0}, 0, 7};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0},new byte[]{0,71,0,1,0}, 10, 10};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0},new byte[]{0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0},new byte[]{0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0},new byte[]{0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0},new byte[]{0,71,1,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0},new byte[]{0,0,1,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0},new byte[]{0,0,1,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0},new byte[]{0,0,1,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0},new byte[]{0,1,0,0,0}, 12, 12};
+            yield return new object[] { new byte[]{0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0},new byte[]{0,1,0,0,0}, 11, 11};
+            yield return new object[] { new byte[]{0,0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0},new byte[]{0,1,0,0,0}, 6, 6};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,0,0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,0,0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,0,0,0,0,1,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,1,0,0,1,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,1,0,0,0,0,0}, 5, 5};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,1,0,0,0,0,0}, 5, 5};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1},new byte[]{0,1,0,0,0,0,0}, 5, 5};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0}, 0, 44};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0}, 0, 43};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0}, 7, 42};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0}, 7, 41};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0}, 7, 11};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0}, 7, 10};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0}, 7, 9};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0,0,0}, 7, 7};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,1,0,0}, 5, 48};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,1,0}, 44, 44};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,1,0,0,0,0}, 5, 19};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,1,0,0,0,1,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0}, 7, 11};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,1,0,0,1,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,1,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,1,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,1,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{0,0,0,0,71,0,1,0,0,0,0,0,0,0,0,0,0,0,71,0,1,0,0,0,0,1,1,0,2,0,1,1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0},new byte[]{0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0}, -1, -1};
+            yield return new object[] { new byte[]{159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133},new byte[]{159,133,159,133,159,133}, 0, 22};
+            yield return new object[] { new byte[]{159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133},new byte[]{159,133,255,159,133}, -1, -1};
+            yield return new object[] { new byte[]{159,133,159,133,159,133,159,133,159,133,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,160,86,160,86,160,86,160,86,160,80},new byte[]{160,86,160,86,160,86,160,86,160,80}, 40, 40};
+            yield return new object[] { new byte[]{159,133,159,133,159,133,159,133,159,133,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,159,127,160,86,160,86,160,86,160,86,160,80,160,80,160,80,160,80,160,80,160,80,160,80,160,86,160,86,160,86,160,86},new byte[]{160,86,160,86,160,86,160,86}, 40, 62};
+            yield return new object[] { new byte[]{159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133,159,133},new byte[]{0,0,0,1}, -1, -1};
+            yield return new object[] { new byte[]{255,160,82,159,134,159,127,255,159,141,160,85,160,82,160,88,255,159,141,159,127,159,134,255,160,88,160,85,160,82,159,141,159,127,159,134,160,88,160,85,160,82,159,141,255,159,127,159,134,160,88,160,85,160,82,159,141,159,127,159,134,160,88,159,141,160,85,255,160,82,159,134,159,141,159,134,160,85,160,82,159,141,159,127,159,134,160,82,159,141,160,85,159,134,255,160,88,159,127,160,82,160,85,159,134,255,159,141,159,127,159,134,160,85,159,141},new byte[]{255,159,141,159,127,159,134,255}, 16, 16};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,50},new byte[]{49,49}, 29, 29};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49},new byte[]{49,49}, 29, 29};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,50},new byte[]{49,49}, 29, 29};
+            yield return new object[] { new byte[]{49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,50},new byte[]{49,49}, -1, -1};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,49},new byte[]{49,49,49}, 29, 29};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,49,50},new byte[]{49,49,49}, 29, 29};
+            yield return new object[] { new byte[]{49,49,49,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,50},new byte[]{49,49,49}, 0, 1};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,50},new byte[]{48,48}, -1, -1};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49},new byte[]{48,48}, -1, -1};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,50},new byte[]{48,48}, -1, -1};
+            yield return new object[] { new byte[]{49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,50},new byte[]{48,48}, -1, -1};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,49},new byte[]{48,48,48}, -1, -1};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,49,50},new byte[]{48,48,48}, -1, -1};
+            yield return new object[] { new byte[]{49,49,49,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,50},new byte[]{48,48,48}, -1, -1};
+            yield return new object[] { new byte[]{48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,49,50},new byte[]{48,49,48,48}, -1, -1};
+            yield return new object[] { new byte[]{49,48,49,49,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,50},new byte[]{49,48,49,49}, 0, 0};
+            yield return new object[] { new byte[]{49,48,49,49,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,48,49,50},new byte[]{160,80,48,160,80,160,80}, -1, -1};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,49,49,49,49,49,49}, 0, 0};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,49,49,49,49,49,49}, 0, 15};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,49,49,49,49,49,49}, 0, 17};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,49,49,49,49,49,49}, 18, 32};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,49,49,49,49,49,49,49,49,49,49,49,49}, 20, 20};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49}, 0, 0};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49}, 0, 0};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49}, -1, -1};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49}, 0, 0};
+            yield return new object[] { new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49},new byte[]{49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49}, 0, 0};
+            yield return new object[] { new byte[]{71,71,71,71,71,71,71,71,71,71,71,71,71,71,49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71},new byte[]{71,71,71,71,71,71,71,71,71,71,71,71,71,71,71}, 60, 60};
+            yield return new object[] { new byte[]{71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,49,48,49,49,49,49,49,49,71,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,49,48,49,49,49,49,49,49,49,49,49,49,49,49,71,71,71,71,71,71,71,71,71,71,71,71,71,71},new byte[]{71,71,71,71,71,71,71,71,71,71,71,71,71,71,71}, 0, 0};
+        }
+
+        [Theory]
+        [MemberData(nameof(IndexOfSubSeqData_Byte))]
+        public static void ValueStartsAndEndsWithTheSameBytes(byte[] searchSpace, byte[] value, int expectedIndexOfValue, int expectedLastIndexOfValue)
+        {
+            Assert.Equal(expectedIndexOfValue, searchSpace.AsSpan().IndexOf(value));
+            Assert.Equal(expectedLastIndexOfValue, searchSpace.AsSpan().LastIndexOf(value));
+        }
     }
 }
diff --git a/src/libraries/System.Memory/tests/Span/IndexOfSequence.char.cs b/src/libraries/System.Memory/tests/Span/IndexOfSequence.char.cs
index bda626153a5d09..b341a79c9b1f33 100644
--- a/src/libraries/System.Memory/tests/Span/IndexOfSequence.char.cs
+++ b/src/libraries/System.Memory/tests/Span/IndexOfSequence.char.cs
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Xunit;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
 
 namespace System.SpanTests
 {
@@ -115,5 +117,104 @@ public static void IndexOfSequenceLengthOneValueJustPasttVeryEnd_Char()
             int index = span.IndexOf(value);
             Assert.Equal(-1, index);
         }
+
+        public static IEnumerable<object[]> IndexOfSubSeqData_Char()
+        {
+            // searchSpace, value, expected IndexOf value, expected LastIndexOf value
+            yield return new object[] { "11111", "111", 0, 2 };
+            yield return new object[] { "1111111111", "1x1", -1, -1 };
+            yield return new object[] { "1111111111", "111", 0, 7 };
+            yield return new object[] { "11111111111x12111", "1x121", 10, 10 };
+            yield return new object[] { "11111111111x12111", "11121", -1, -1 };
+            yield return new object[] { "1111111111x121111", "11121", -1, -1 };
+            yield return new object[] { "11111x12111111111", "11121", -1, -1 };
+            yield return new object[] { "11111111111x12111", "1x211", -1, -1 };
+            yield return new object[] { "11111111111x12111", "11211", -1, -1 };
+            yield return new object[] { "1111111111x121111", "11211", -1, -1 };
+            yield return new object[] { "11111x12111111111", "11211", -1, -1 };
+            yield return new object[] { "11111111111x12111", "12111", 12, 12 };
+            yield return new object[] { "1111111111x121111", "12111", 11, 11 };
+            yield return new object[] { "11111x12111111111", "12111", 6, 6 };
+            yield return new object[] { "1111x1211111111111x12", "11121", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12", "11121", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12", "111121", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12", "1111121", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12", "1111121", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12", "1111121", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12", "1211211", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12", "1211111", 5, 5 };
+            yield return new object[] { "1111x1211111111111x12", "1211111", 5, 5 };
+            yield return new object[] { "1111x1211111111111x12", "1211111", 5, 5 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111", 0, 44 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1111", 0, 43 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11111", 7, 42 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111111", 7, 41 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1111111", 7, 11 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11111111", 7, 10 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111111111", 7, 9 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11111111111", 7, 7 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1111111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11111111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111111111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11111111111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111111111111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1211", 5, 48 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11121", 44, 44 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "121111", 5, 19 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "12111211", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1111111", 7, 11 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1121121111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1111211111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111111211111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1121111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11122111112111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1111111211111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111211111111111111", -1, -1 };
+            yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11111211111121111111", -1, -1 };
+            yield return new object[] { "жжжжжжжжжжжжжж", "жжж", 0, 11 };
+            yield return new object[] { "жжжжжжжжжжжжжжжжжжжжжжжжжжжж", "ж0ж", -1, -1 };
+            yield return new object[] { "жжжжжаааааааааааааааччччс", "ччччс", 20, 20 };
+            yield return new object[] { "жжжжжаааааааааааааааччччсссссссчччч", "чччч", 20, 31 };
+            yield return new object[] { "жжжжжжжжжжжжжжжжжжжжжжжжжжжж", "1112", -1, -1 };
+            yield return new object[] { "0уза0оцущ0оаз0щцуоазщцуо0азщцуоазщоц0узозцуоазуоцз0щауцз0оазцо", "0оаз0", 9, 9 };
+            yield return new object[] { "abababababababababababababababbc", "bb", 29, 29 };
+            yield return new object[] { "abababababababababababababababb", "bb", 29, 29 };
+            yield return new object[] { "abababababababababababababababbc", "bb", 29, 29 };
+            yield return new object[] { "babababababababababababababababc", "bb", -1, -1 };
+            yield return new object[] { "abababababababababababababababbb", "bbb", 29, 29 };
+            yield return new object[] { "abababababababababababababababbbc", "bbb", 29, 29 };
+            yield return new object[] { "bbbbabababababababababababababababc", "bbb", 0, 1 };
+            yield return new object[] { "abababababababababababababababbc", "aa", -1, -1 };
+            yield return new object[] { "abababababababababababababababb", "aa", -1, -1 };
+            yield return new object[] { "abababababababababababababababbc", "aa", -1, -1 };
+            yield return new object[] { "babababababababababababababababc", "aa", -1, -1 };
+            yield return new object[] { "abababababababababababababababbb", "aaa", -1, -1 };
+            yield return new object[] { "abababababababababababababababbbc", "aaa", -1, -1 };
+            yield return new object[] { "bbbbabababababababababababababababc", "aaa", -1, -1 };
+            yield return new object[] { "ababababababababababababababababbc", "abaa", -1, -1 };
+            yield return new object[] { "babbbabababababababababababababababc", "babb", 0, 0 };
+            yield return new object[] { "babbbabababababababababababababababc", "сaсс", -1, -1 };
+            yield return new object[] { "babbbbbbbbbbbbb", "babbbbbbbbbbbb", 0, 0 };
+            yield return new object[] { "babbbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbbbbbbb", 0, 15 };
+            yield return new object[] { "babbbbbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbbbbbbb", 0, 17 };
+            yield return new object[] { "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbbbbbbb", 18, 32 };
+            yield return new object[] { "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", "bbbbbbbbbbbbb", 20, 20 };
+            yield return new object[] { "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", 0, 0 };
+            yield return new object[] { "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbb", 0, 0 };
+            yield return new object[] { "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbbb", -1, -1 };
+            yield return new object[] { "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", 0, 0 };
+            yield return new object[] { "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbb", 0, 0 };
+            yield return new object[] { "xxxxxxxxxxxxxxbabbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbbxxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxx", 60, 60 };
+            yield return new object[] { "xxxxxxxxxxxxxxxbabbbbbbxbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbbxxxxxxxxxxxxxx", "xxxxxxxxxxxxxxx", 0, 0 };
+        }
+
+        [Theory]
+        [MemberData(nameof(IndexOfSubSeqData_Char))]
+        public static void ValueStartsAndEndsWithTheSameChars(string searchSpace, string value, int expectedIndexOfValue, int expectedLastIndexOfValue)
+        {
+            Assert.Equal(expectedIndexOfValue, searchSpace.AsSpan().IndexOf(value));
+            Assert.Equal(expectedLastIndexOfValue, searchSpace.AsSpan().LastIndexOf(value));
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs
index b49dea6f3638ac..3c7c13fa645f06 100644
--- a/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs
@@ -580,12 +580,25 @@ ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
         {
-            if (Unsafe.SizeOf<T>() == sizeof(byte) && RuntimeHelpers.IsBitwiseEquatable<T>())
-                return SpanHelpers.LastIndexOf(
-                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
-                    span.Length,
-                    ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
-                    value.Length);
+            if (RuntimeHelpers.IsBitwiseEquatable<T>())
+            {
+                if (Unsafe.SizeOf<T>() == sizeof(byte))
+                {
+                    return SpanHelpers.LastIndexOf(
+                        ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                        span.Length,
+                        ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
+                        value.Length);
+                }
+                if (Unsafe.SizeOf<T>() == sizeof(char))
+                {
+                    return SpanHelpers.LastIndexOf(
+                        ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
+                        span.Length,
+                        ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
+                        value.Length);
+                }
+            }
 
             return SpanHelpers.LastIndexOf<T>(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs
index 6a7141cd01cd48..419a1c9f5f1146 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs
@@ -708,5 +708,25 @@ public static nuint RotateRight(nuint value, int offset)
             return (nuint)RotateRight((uint)value, offset);
 #endif
         }
+
+        /// <summary>
+        /// Reset the lowest significant bit in the given value
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static uint ResetLowestSetBit(uint value)
+        {
+            // It's lowered to BLSR on x86
+            return value & (value - 1);
+        }
+
+        /// <summary>
+        /// Reset specific bit in the given value
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static uint ResetBit(uint value, int bitPos)
+        {
+            // TODO: Recognize BTR on x86 and LSL+BIC on ARM
+            return value & ~(uint)(1 << bitPos);
+        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs
index e94b1dfe672b2b..3a3bc586912ae8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs
@@ -22,12 +22,21 @@ public static int IndexOf(ref byte searchSpace, int searchSpaceLength, ref byte
             if (valueLength == 0)
                 return 0;  // A zero-length sequence is always treated as "found" at the start of the search space.
 
-            byte valueHead = value;
-            ref byte valueTail = ref Unsafe.Add(ref value, 1);
             int valueTailLength = valueLength - 1;
-            int remainingSearchSpaceLength = searchSpaceLength - valueTailLength;
+            if (valueTailLength == 0)
+                return IndexOf(ref searchSpace, value, searchSpaceLength); // for single-byte values use plain IndexOf
 
             int offset = 0;
+            byte valueHead = value;
+            int searchSpaceMinusValueTailLength = searchSpaceLength - valueTailLength;
+            if (Vector128.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector128<byte>.Count)
+            {
+                goto SEARCH_TWO_BYTES;
+            }
+
+            ref byte valueTail = ref Unsafe.Add(ref value, 1);
+            int remainingSearchSpaceLength = searchSpaceMinusValueTailLength;
+
             while (remainingSearchSpaceLength > 0)
             {
                 // Do a quick search for the first element of "value".
@@ -42,13 +51,264 @@ public static int IndexOf(ref byte searchSpace, int searchSpaceLength, ref byte
                     break;  // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
 
                 // Found the first element of "value". See if the tail matches.
-                if (SequenceEqual(ref Unsafe.Add(ref searchSpace, offset + 1), ref valueTail, (nuint)valueTailLength))  // The (nuint)-cast is necessary to pick the correct overload
+                if (SequenceEqual(
+                        ref Unsafe.Add(ref searchSpace, offset + 1),
+                        ref valueTail, (nuint)(uint)valueTailLength))  // The (nuint)-cast is necessary to pick the correct overload
                     return offset;  // The tail matched. Return a successful find.
 
                 remainingSearchSpaceLength--;
                 offset++;
             }
             return -1;
+
+            // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+            // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
+        SEARCH_TWO_BYTES:
+            if (Avx2.IsSupported && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0)
+            {
+                // Find the last unique (which is not equal to ch1) byte
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                byte ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == value && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector256<byte> ch1 = Vector256.Create(value);
+                Vector256<byte> ch2 = Vector256.Create(ch2Val);
+
+                do
+                {
+                    Debug.Assert(offset >= 0);
+                    // Make sure we don't go out of bounds
+                    Debug.Assert(offset + ch1ch2Distance + Vector256<byte>.Count <= searchSpaceLength);
+
+                    Vector256<byte> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace, (nuint)offset));
+                    Vector256<byte> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance)));
+                    Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    if (cmpAnd != Vector256<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            int bitPos = BitOperations.TrailingZeroCount(mask);
+                            if (valueLength == 2 || // we already matched two bytes
+                                SequenceEqual(
+                                    ref Unsafe.Add(ref searchSpace, offset + bitPos),
+                                    ref value, (nuint)(uint)valueLength)) // The (nuint)-cast is necessary to pick the correct overload
+                            {
+                                return offset + bitPos;
+                            }
+                            mask = BitOperations.ResetLowestSetBit(mask); // Clear the lowest set bit
+                        } while (mask != 0);
+                    }
+                    offset += Vector256<byte>.Count;
+
+                    if (offset == searchSpaceMinusValueTailLength)
+                        return -1;
+
+                    // Overlap with the current chunk for trailing elements
+                    if (offset > searchSpaceMinusValueTailLength - Vector256<byte>.Count)
+                        offset = searchSpaceMinusValueTailLength - Vector256<byte>.Count;
+                } while (true);
+            }
+            else // 128bit vector path (SSE2 or AdvSimd)
+            {
+                // Find the last unique (which is not equal to ch1) byte
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                byte ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == value && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector128<byte> ch1 = Vector128.Create(value);
+                Vector128<byte> ch2 = Vector128.Create(ch2Val);
+
+                do
+                {
+                    Debug.Assert(offset >= 0);
+                    // Make sure we don't go out of bounds
+                    Debug.Assert(offset + ch1ch2Distance + Vector128<byte>.Count <= searchSpaceLength);
+
+                    Vector128<byte> cmpCh1 = Vector128.Equals(ch1, Vector128.LoadUnsafe(ref searchSpace, (nuint)offset));
+                    Vector128<byte> cmpCh2 = Vector128.Equals(ch2, Vector128.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance)));
+                    Vector128<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    if (cmpAnd != Vector128<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            int bitPos = BitOperations.TrailingZeroCount(mask);
+                            if (valueLength == 2 || // we already matched two bytes
+                                SequenceEqual(
+                                    ref Unsafe.Add(ref searchSpace, offset + bitPos),
+                                    ref value, (nuint)(uint)valueLength)) // The (nuint)-cast is necessary to pick the correct overload
+                            {
+                                return offset + bitPos;
+                            }
+                            // Clear the lowest set bit
+                            mask = BitOperations.ResetLowestSetBit(mask);
+                        } while (mask != 0);
+                    }
+                    offset += Vector128<byte>.Count;
+
+                    if (offset == searchSpaceMinusValueTailLength)
+                        return -1;
+
+                    // Overlap with the current chunk for trailing elements
+                    if (offset > searchSpaceMinusValueTailLength - Vector128<byte>.Count)
+                        offset = searchSpaceMinusValueTailLength - Vector128<byte>.Count;
+                } while (true);
+            }
+        }
+
+        public static int LastIndexOf(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
+        {
+            Debug.Assert(searchSpaceLength >= 0);
+            Debug.Assert(valueLength >= 0);
+
+            if (valueLength == 0)
+                return searchSpaceLength;  // A zero-length sequence is always treated as "found" at the end of the search space.
+
+            int valueTailLength = valueLength - 1;
+            if (valueTailLength == 0)
+                return LastIndexOf(ref searchSpace, value, searchSpaceLength); // for single-byte values use plain LastIndexOf
+
+            int offset = 0;
+            byte valueHead = value;
+            int searchSpaceMinusValueTailLength = searchSpaceLength - valueTailLength;
+            if (Vector128.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector128<byte>.Count)
+            {
+                goto SEARCH_TWO_BYTES;
+            }
+
+            ref byte valueTail = ref Unsafe.Add(ref value, 1);
+
+            while (true)
+            {
+                Debug.Assert(0 <= offset && offset <= searchSpaceLength); // Ensures no deceptive underflows in the computation of "remainingSearchSpaceLength".
+                int remainingSearchSpaceLength = searchSpaceLength - offset - valueTailLength;
+                if (remainingSearchSpaceLength <= 0)
+                    break;  // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
+
+                // Do a quick search for the first element of "value".
+                int relativeIndex = LastIndexOf(ref searchSpace, valueHead, remainingSearchSpaceLength);
+                if (relativeIndex < 0)
+                    break;
+
+                // Found the first element of "value". See if the tail matches.
+                if (SequenceEqual(
+                        ref Unsafe.Add(ref searchSpace, relativeIndex + 1),
+                        ref valueTail, (nuint)(uint)valueTailLength)) // The (nuint)-cast is necessary to pick the correct overload
+                    return relativeIndex;  // The tail matched. Return a successful find.
+
+                offset += remainingSearchSpaceLength - relativeIndex;
+            }
+            return -1;
+
+        // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+        // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
+        SEARCH_TWO_BYTES:
+            if (Avx2.IsSupported && searchSpaceMinusValueTailLength >= Vector256<byte>.Count)
+            {
+                offset = searchSpaceMinusValueTailLength - Vector256<byte>.Count;
+
+                // Find the last unique (which is not equal to ch1) byte
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                byte ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == value && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector256<byte> ch1 = Vector256.Create(value);
+                Vector256<byte> ch2 = Vector256.Create(ch2Val);
+                do
+                {
+                    Vector256<byte> cmpCh1 = Vector256.Equals(ch1, Vector256.LoadUnsafe(ref searchSpace, (nuint)offset));
+                    Vector256<byte> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance)));
+                    Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    if (cmpAnd != Vector256<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            // unlike IndexOf, here we use LZCNT to process matches starting from the end
+                            int bitPos = 31 - BitOperations.LeadingZeroCount(mask);
+                            if (valueLength == 2 || // we already matched two bytes
+                                SequenceEqual(
+                                    ref Unsafe.Add(ref searchSpace, offset + bitPos),
+                                    ref value, (nuint)(uint)valueLength)) // The (nuint)-cast is necessary to pick the correct overload
+                            {
+                                return bitPos + offset;
+                            }
+                            // Clear the highest set bit.
+                            mask = BitOperations.ResetBit(mask, bitPos);
+                        } while (mask != 0);
+                    }
+
+                    offset -= Vector256<byte>.Count;
+                    if (offset == -Vector256<byte>.Count)
+                        return -1;
+                    // Overlap with the current chunk if there is not enough room for the next one
+                    if (offset < 0)
+                        offset = 0;
+                } while (true);
+            }
+            else // 128bit vector path (SSE2 or AdvSimd)
+            {
+                offset = searchSpaceMinusValueTailLength - Vector128<byte>.Count;
+
+                // Find the last unique (which is not equal to ch1) byte
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                byte ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == value && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector128<byte> ch1 = Vector128.Create(value);
+                Vector128<byte> ch2 = Vector128.Create(ch2Val);
+
+                do
+                {
+                    Vector128<byte> cmpCh1 = Vector128.Equals(ch1, Vector128.LoadUnsafe(ref searchSpace, (nuint)offset));
+                    Vector128<byte> cmpCh2 = Vector128.Equals(ch2, Vector128.LoadUnsafe(ref searchSpace, (nuint)(offset + ch1ch2Distance)));
+                    Vector128<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    // it's especially important for ARM where ExtractMostSignificantBits is not cheap
+                    if (cmpAnd != Vector128<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            // unlike IndexOf, here we use LZCNT to process matches starting from the end
+                            int bitPos = 31 - BitOperations.LeadingZeroCount(mask);
+                            if (valueLength == 2 || // we already matched two bytes
+                                SequenceEqual(
+                                    ref Unsafe.Add(ref searchSpace, offset + bitPos),
+                                    ref value, (nuint)(uint)valueLength)) // The (nuint)-cast is necessary to pick the correct overload
+                            {
+                                return bitPos + offset;
+                            }
+                            // Clear the highest set bit.
+                            mask = BitOperations.ResetBit(mask, bitPos);
+                        } while (mask != 0);
+                    }
+
+                    offset -= Vector128<byte>.Count;
+                    if (offset == -Vector128<byte>.Count)
+                        return -1;
+                    // Overlap with the current chunk if there is not enough room for the next one
+                    if (offset < 0)
+                        offset = 0;
+
+                } while (true);
+            }
         }
 
         // Adapted from IndexOf(...)
@@ -408,40 +668,6 @@ public static unsafe int IndexOf(ref byte searchSpace, byte value, int length)
             return (int)(offset + 7);
         }
 
-        public static int LastIndexOf(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
-        {
-            Debug.Assert(searchSpaceLength >= 0);
-            Debug.Assert(valueLength >= 0);
-
-            if (valueLength == 0)
-                return searchSpaceLength;  // A zero-length sequence is always treated as "found" at the end of the search space.
-
-            byte valueHead = value;
-            ref byte valueTail = ref Unsafe.Add(ref value, 1);
-            int valueTailLength = valueLength - 1;
-
-            int offset = 0;
-            while (true)
-            {
-                Debug.Assert(0 <= offset && offset <= searchSpaceLength); // Ensures no deceptive underflows in the computation of "remainingSearchSpaceLength".
-                int remainingSearchSpaceLength = searchSpaceLength - offset - valueTailLength;
-                if (remainingSearchSpaceLength <= 0)
-                    break;  // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
-
-                // Do a quick search for the first element of "value".
-                int relativeIndex = LastIndexOf(ref searchSpace, valueHead, remainingSearchSpaceLength);
-                if (relativeIndex < 0)
-                    break;
-
-                // Found the first element of "value". See if the tail matches.
-                if (SequenceEqual(ref Unsafe.Add(ref searchSpace, relativeIndex + 1), ref valueTail, (nuint)(uint)valueTailLength))  // The (nunit)-cast is necessary to pick the correct overload
-                    return relativeIndex;  // The tail matched. Return a successful find.
-
-                offset += remainingSearchSpaceLength - relativeIndex;
-            }
-            return -1;
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         public static int LastIndexOf(ref byte searchSpace, byte value, int length)
         {
@@ -1564,13 +1790,11 @@ public static unsafe bool SequenceEqual(ref byte first, ref byte second, nuint l
                     // This becomes a conditional jmp foward to not favor it.
                     goto NotEqual;
                 }
-                // Use Vector128.Size as Vector128<byte>.Count doesn't inline at R2R time
-                // https://github.com/dotnet/runtime/issues/32714
-                else if (length >= Vector128.Size)
+                else if (length >= (nuint)Vector128<byte>.Count)
                 {
                     Vector128<byte> vecResult;
                     nuint offset = 0;
-                    nuint lengthToExamine = length - Vector128.Size;
+                    nuint lengthToExamine = length - (nuint)Vector128<byte>.Count;
                     // Unsigned, so it shouldn't have overflowed larger than length (rather than negative)
                     Debug.Assert(lengthToExamine < length);
                     if (lengthToExamine != 0)
@@ -1584,7 +1808,7 @@ public static unsafe bool SequenceEqual(ref byte first, ref byte second, nuint l
                             {
                                 goto NotEqual;
                             }
-                            offset += Vector128.Size;
+                            offset += (nuint)Vector128<byte>.Count;
                         } while (lengthToExamine > offset);
                     }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs
index 753e5301b503b1..fb00b062538f2f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs
@@ -22,38 +22,315 @@ public static int IndexOf(ref char searchSpace, int searchSpaceLength, ref char
             if (valueLength == 0)
                 return 0;  // A zero-length sequence is always treated as "found" at the start of the search space.
 
-            char valueHead = value;
-            ref char valueTail = ref Unsafe.Add(ref value, 1);
             int valueTailLength = valueLength - 1;
-            int remainingSearchSpaceLength = searchSpaceLength - valueTailLength;
+            if (valueTailLength == 0)
+            {
+                // for single-char values use plain IndexOf
+                return IndexOf(ref searchSpace, value, searchSpaceLength);
+            }
+
+            int offset = 0;
+            char valueHead = value;
+            int searchSpaceMinusValueTailLength = searchSpaceLength - valueTailLength;
+            if (Vector128.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector128<ushort>.Count)
+            {
+                goto SEARCH_TWO_CHARS;
+            }
+
+            ref byte valueTail = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref value, 1));
+            int remainingSearchSpaceLength = searchSpaceMinusValueTailLength;
 
-            int index = 0;
             while (remainingSearchSpaceLength > 0)
             {
                 // Do a quick search for the first element of "value".
-                int relativeIndex = IndexOf(ref Unsafe.Add(ref searchSpace, index), valueHead, remainingSearchSpaceLength);
+                int relativeIndex = IndexOf(ref Unsafe.Add(ref searchSpace, offset), valueHead, remainingSearchSpaceLength);
                 if (relativeIndex < 0)
                     break;
 
                 remainingSearchSpaceLength -= relativeIndex;
-                index += relativeIndex;
+                offset += relativeIndex;
 
                 if (remainingSearchSpaceLength <= 0)
                     break;  // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
 
                 // Found the first element of "value". See if the tail matches.
                 if (SequenceEqual(
-                    ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, index + 1)),
-                    ref Unsafe.As<char, byte>(ref valueTail),
-                    (nuint)(uint)valueTailLength * 2))
+                        ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + 1)),
+                        ref valueTail,
+                        (nuint)(uint)valueTailLength * 2))
                 {
-                    return index;  // The tail matched. Return a successful find.
+                    return offset;  // The tail matched. Return a successful find.
                 }
 
                 remainingSearchSpaceLength--;
-                index++;
+                offset++;
             }
             return -1;
+
+            // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+            // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
+        SEARCH_TWO_CHARS:
+            if (Avx2.IsSupported && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0)
+            {
+                // Find the last unique (which is not equal to ch1) character
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == valueHead && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector256<ushort> ch1 = Vector256.Create((ushort)valueHead);
+                Vector256<ushort> ch2 = Vector256.Create(ch2Val);
+
+                do
+                {
+                    // Make sure we don't go out of bounds
+                    Debug.Assert(offset + ch1ch2Distance + Vector256<ushort>.Count <= searchSpaceLength);
+
+                    Vector256<ushort> cmpCh1 = Vector256.Equals(ch1, LoadVector256(ref searchSpace, offset));
+                    Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, LoadVector256(ref searchSpace, offset + ch1ch2Distance));
+                    Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    if (cmpAnd != Vector256<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            int bitPos = BitOperations.TrailingZeroCount(mask);
+                            // div by 2 (shr) because we work with 2-byte chars
+                            int charPos = (int)((uint)bitPos / 2);
+                            if (valueLength == 2 || // we already matched two chars
+                                SequenceEqual(
+                                    ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
+                                    ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
+                            {
+                                return offset + charPos;
+                            }
+
+                            // Clear two the lowest set bits
+                            if (Bmi1.IsSupported)
+                                mask = Bmi1.ResetLowestSetBit(Bmi1.ResetLowestSetBit(mask));
+                            else
+                                mask &= ~(uint)(0b11 << bitPos);
+                        } while (mask != 0);
+                    }
+                    offset += Vector256<ushort>.Count;
+
+                    if (offset == searchSpaceMinusValueTailLength)
+                        return -1;
+
+                    // Overlap with the current chunk for trailing elements
+                    if (offset > searchSpaceMinusValueTailLength - Vector256<ushort>.Count)
+                        offset = searchSpaceMinusValueTailLength - Vector256<ushort>.Count;
+                } while (true);
+            }
+            else // 128bit vector path (SSE2 or AdvSimd)
+            {
+                // Find the last unique (which is not equal to ch1) character
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == valueHead && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector128<ushort> ch1 = Vector128.Create((ushort)valueHead);
+                Vector128<ushort> ch2 = Vector128.Create(ch2Val);
+
+                do
+                {
+                    // Make sure we don't go out of bounds
+                    Debug.Assert(offset + ch1ch2Distance + Vector128<ushort>.Count <= searchSpaceLength);
+
+                    Vector128<ushort> cmpCh1 = Vector128.Equals(ch1, LoadVector128(ref searchSpace, offset));
+                    Vector128<ushort> cmpCh2 = Vector128.Equals(ch2, LoadVector128(ref searchSpace, offset + ch1ch2Distance));
+                    Vector128<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    if (cmpAnd != Vector128<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            int bitPos = BitOperations.TrailingZeroCount(mask);
+                            // div by 2 (shr) because we work with 2-byte chars
+                            int charPos = (int)((uint)bitPos / 2);
+                            if (valueLength == 2 || // we already matched two chars
+                                SequenceEqual(
+                                    ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
+                                    ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
+                            {
+                                return offset + charPos;
+                            }
+
+                            // Clear two lowest set bits
+                            if (Bmi1.IsSupported)
+                                mask = Bmi1.ResetLowestSetBit(Bmi1.ResetLowestSetBit(mask));
+                            else
+                                mask &= ~(uint)(0b11 << bitPos);
+                        } while (mask != 0);
+                    }
+                    offset += Vector128<ushort>.Count;
+
+                    if (offset == searchSpaceMinusValueTailLength)
+                        return -1;
+
+                    // Overlap with the current chunk for trailing elements
+                    if (offset > searchSpaceMinusValueTailLength - Vector128<ushort>.Count)
+                        offset = searchSpaceMinusValueTailLength - Vector128<ushort>.Count;
+                } while (true);
+            }
+        }
+
+        public static int LastIndexOf(ref char searchSpace, int searchSpaceLength, ref char value, int valueLength)
+        {
+            Debug.Assert(searchSpaceLength >= 0);
+            Debug.Assert(valueLength >= 0);
+
+            if (valueLength == 0)
+                return searchSpaceLength;  // A zero-length sequence is always treated as "found" at the end of the search space.
+
+            int valueTailLength = valueLength - 1;
+            if (valueTailLength == 0)
+                return LastIndexOf(ref searchSpace, value, searchSpaceLength); // for single-char values use plain LastIndexOf
+
+            int offset = 0;
+            char valueHead = value;
+            int searchSpaceMinusValueTailLength = searchSpaceLength - valueTailLength;
+            if (Vector128.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector128<ushort>.Count)
+            {
+                goto SEARCH_TWO_CHARS;
+            }
+
+            ref byte valueTail = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref value, 1));
+
+            while (true)
+            {
+                Debug.Assert(0 <= offset && offset <= searchSpaceLength); // Ensures no deceptive underflows in the computation of "remainingSearchSpaceLength".
+                int remainingSearchSpaceLength = searchSpaceLength - offset - valueTailLength;
+                if (remainingSearchSpaceLength <= 0)
+                    break;  // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
+
+                // Do a quick search for the first element of "value".
+                int relativeIndex = LastIndexOf(ref searchSpace, valueHead, remainingSearchSpaceLength);
+                if (relativeIndex == -1)
+                    break;
+
+                // Found the first element of "value". See if the tail matches.
+                if (SequenceEqual(
+                        ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, relativeIndex + 1)),
+                        ref valueTail, (nuint)(uint)valueTailLength * 2))
+                {
+                    return relativeIndex; // The tail matched. Return a successful find.
+                }
+
+                offset += remainingSearchSpaceLength - relativeIndex;
+            }
+            return -1;
+
+            // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+            // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
+        SEARCH_TWO_CHARS:
+            if (Avx2.IsSupported && searchSpaceMinusValueTailLength >= Vector256<ushort>.Count)
+            {
+                offset = searchSpaceMinusValueTailLength - Vector256<ushort>.Count;
+
+                // Find the last unique (which is not equal to ch1) char
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                char ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == valueHead && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector256<ushort> ch1 = Vector256.Create((ushort)valueHead);
+                Vector256<ushort> ch2 = Vector256.Create((ushort)ch2Val);
+
+                do
+                {
+
+                    Vector256<ushort> cmpCh1 = Vector256.Equals(ch1, LoadVector256(ref searchSpace, (nuint)offset));
+                    Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, LoadVector256(ref searchSpace, (nuint)(offset + ch1ch2Distance)));
+                    Vector256<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    if (cmpAnd != Vector256<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            // unlike IndexOf, here we use LZCNT to process matches starting from the end
+                            int bitPos = 30 - BitOperations.LeadingZeroCount(mask);
+                            int charPos = (int)((uint)bitPos / 2);
+
+                            if (valueLength == 2 || // we already matched two chars
+                                SequenceEqual(
+                                    ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
+                                    ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
+                            {
+                                return charPos + offset;
+                            }
+                            mask &= ~(uint)(0b11 << bitPos); // clear two highest set bits.
+                        } while (mask != 0);
+                    }
+
+                    offset -= Vector256<ushort>.Count;
+                    if (offset == -Vector256<ushort>.Count)
+                        return -1;
+                    // Overlap with the current chunk if there is not enough room for the next one
+                    if (offset < 0)
+                        offset = 0;
+                } while (true);
+            }
+            else // 128bit vector path (SSE2 or AdvSimd)
+            {
+                offset = searchSpaceMinusValueTailLength - Vector128<ushort>.Count;
+
+                // Find the last unique (which is not equal to ch1) char
+                // the algorithm is fine if both are equal, just a little bit less efficient
+                char ch2Val = Unsafe.Add(ref value, valueTailLength);
+                int ch1ch2Distance = valueTailLength;
+                while (ch2Val == value && ch1ch2Distance > 1)
+                    ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
+
+                Vector128<ushort> ch1 = Vector128.Create((ushort)value);
+                Vector128<ushort> ch2 = Vector128.Create((ushort)ch2Val);
+
+                do
+                {
+                    Vector128<ushort> cmpCh1 = Vector128.Equals(ch1, LoadVector128(ref searchSpace, (nuint)offset));
+                    Vector128<ushort> cmpCh2 = Vector128.Equals(ch2, LoadVector128(ref searchSpace, (nuint)(offset + ch1ch2Distance)));
+                    Vector128<byte> cmpAnd = (cmpCh1 & cmpCh2).AsByte();
+
+                    // Early out: cmpAnd is all zeros
+                    // it's especially important for ARM where ExtractMostSignificantBits is not cheap
+                    if (cmpAnd != Vector128<byte>.Zero)
+                    {
+                        uint mask = cmpAnd.ExtractMostSignificantBits();
+                        do
+                        {
+                            // unlike IndexOf, here we use LZCNT to process matches starting from the end
+                            int bitPos = 30 - BitOperations.LeadingZeroCount(mask);
+                            int charPos = (int)((uint)bitPos / 2);
+
+                            if (valueLength == 2 || // we already matched two chars
+                                SequenceEqual(
+                                    ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
+                                    ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
+                            {
+                                return charPos + offset;
+                            }
+                            mask &= ~(uint)(0b11 << bitPos); // clear two the highest set bits.
+                        } while (mask != 0);
+                    }
+
+                    offset -= Vector128<ushort>.Count;
+                    if (offset == -Vector128<ushort>.Count)
+                        return -1;
+                    // Overlap with the current chunk if there is not enough room for the next one
+                    if (offset < 0)
+                        offset = 0;
+                } while (true);
+            }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveOptimization)]
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs
index 91d2a34a477963..27944aff4876c6 100644
--- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs
@@ -774,11 +774,17 @@ public static int LastIndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T
             if (valueLength == 0)
                 return searchSpaceLength;  // A zero-length sequence is always treated as "found" at the end of the search space.
 
-            T valueHead = value;
-            ref T valueTail = ref Unsafe.Add(ref value, 1);
             int valueTailLength = valueLength - 1;
+            if (valueTailLength == 0)
+            {
+                return LastIndexOf(ref searchSpace, value, searchSpaceLength);
+            }
 
             int index = 0;
+
+            T valueHead = value;
+            ref T valueTail = ref Unsafe.Add(ref value, 1);
+
             while (true)
             {
                 Debug.Assert(0 <= index && index <= searchSpaceLength); // Ensures no deceptive underflows in the computation of "remainingSearchSpaceLength".

From 4e165d3cc623282baa627ae468220c00f71626c6 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Tue, 25 Jan 2022 14:46:37 -0500
Subject: [PATCH 066/161] [main] Update dependencies from dotnet/arcade
 dotnet/xharness dotnet/icu dotnet/hotreload-utils dotnet/llvm-project
 (#64265)

* Update dependencies from https://github.com/dotnet/arcade build 20220124.13

Microsoft.DotNet.XUnitConsoleRunner , Microsoft.DotNet.CodeAnalysis , Microsoft.DotNet.Build.Tasks.Workloads , Microsoft.DotNet.Build.Tasks.Templating , Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk , Microsoft.DotNet.Build.Tasks.Packaging , Microsoft.DotNet.Build.Tasks.Installers , Microsoft.DotNet.Build.Tasks.Feed , Microsoft.DotNet.Build.Tasks.Archives , Microsoft.DotNet.Arcade.Sdk , Microsoft.DotNet.ApiCompat , Microsoft.DotNet.XUnitExtensions , Microsoft.DotNet.GenAPI , Microsoft.DotNet.VersionTools.Tasks , Microsoft.DotNet.GenFacades , Microsoft.DotNet.SharedFramework.Sdk , Microsoft.DotNet.RemoteExecutor , Microsoft.DotNet.PackageTesting , Microsoft.DotNet.Helix.Sdk
 From Version 2.5.1-beta.22071.6 -> To Version 2.5.1-beta.22074.13

* Update dependencies from https://github.com/dotnet/xharness build 20220124.1

Microsoft.DotNet.XHarness.CLI , Microsoft.DotNet.XHarness.TestRunners.Common , Microsoft.DotNet.XHarness.TestRunners.Xunit
 From Version 1.0.0-prerelease.22071.1 -> To Version 1.0.0-prerelease.22074.1

* Update dependencies from https://github.com/dotnet/icu build 20220124.5

Microsoft.NETCore.Runtime.ICU.Transport
 From Version 7.0.0-preview.2.22071.2 -> To Version 7.0.0-preview.2.22074.5

* Update dependencies from https://github.com/dotnet/hotreload-utils build 20220124.1

Microsoft.DotNet.HotReload.Utils.Generator.BuildTool
 From Version 1.0.2-alpha.0.22069.1 -> To Version 1.0.2-alpha.0.22074.1

* Update dependencies from https://github.com/dotnet/llvm-project build 20220124.2

runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools , runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk , runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk , runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools , runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk , runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools , runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk , runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools
 From Version 11.1.0-alpha.1.22067.2 -> To Version 11.1.0-alpha.1.22074.2

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
---
 .config/dotnet-tools.json                     |   2 +-
 eng/Version.Details.xml                       | 128 +++++++++---------
 eng/Versions.props                            |  56 ++++----
 eng/common/templates/job/execute-sdl.yml      |  10 +-
 eng/common/templates/job/onelocbuild.yml      |  19 ++-
 eng/common/templates/jobs/jobs.yml            |  10 +-
 .../templates/post-build/post-build.yml       |  42 ++++--
 .../post-build/setup-maestro-vars.yml         |   1 +
 global.json                                   |   8 +-
 9 files changed, 162 insertions(+), 114 deletions(-)

diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
index 26dc5ae6a75f47..f6ec0a4e1da7e2 100644
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -15,7 +15,7 @@
       ]
     },
     "microsoft.dotnet.xharness.cli": {
-      "version": "1.0.0-prerelease.22071.1",
+      "version": "1.0.0-prerelease.22074.1",
       "commands": [
         "xharness"
       ]
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index b01aa4c37ed5bd..0e09fa1f297b36 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -1,8 +1,8 @@
 <Dependencies>
   <ProductDependencies>
-    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="7.0.0-preview.2.22071.2">
+    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="7.0.0-preview.2.22074.5">
       <Uri>https://github.com/dotnet/icu</Uri>
-      <Sha>8a4a45cc99e7d6e5244c16f581171633091b96b3</Sha>
+      <Sha>80a658fa6aa6601d67bfe5a294e0d1b7e1184a5c</Sha>
     </Dependency>
     <Dependency Name="System.Net.MsQuic.Transport" Version="7.0.0-alpha.1.21529.3">
       <Uri>https://github.com/dotnet/msquic</Uri>
@@ -50,77 +50,77 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenAPI" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.GenAPI" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenFacades" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.GenFacades" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Templating" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Templating" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Workloads" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Workloads" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NET.Test.Sdk" Version="16.9.0-preview-20201201-01">
       <Uri>https://github.com/microsoft/vstest</Uri>
@@ -170,37 +170,37 @@
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
       <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
-    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
-    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
-    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
-    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
-    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22067.2">
+    <Dependency Name="runtime.osx.10.12-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
-      <Sha>79a6d232058e2c2f1d9e833355b72f07fe342a3b</Sha>
+      <Sha>44adf6c047663fe20c388bfb769e18dd3c91f7e0</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NETCore.App.Runtime.win-x64" Version="7.0.0-alpha.1.22073.5">
       <Uri>https://github.com/dotnet/runtime</Uri>
@@ -238,21 +238,21 @@
       <Uri>https://github.com/dotnet/linker</Uri>
       <Sha>e485816b48273d03bd6266a64dad9bea97f861d5</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Common" Version="1.0.0-prerelease.22071.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Common" Version="1.0.0-prerelease.22074.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>bd2a12f9cc6c93c249f987b42c1c761550369674</Sha>
+      <Sha>0137095821e2e5a9e030d97248503387b8d72a18</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.22071.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.22074.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>bd2a12f9cc6c93c249f987b42c1c761550369674</Sha>
+      <Sha>0137095821e2e5a9e030d97248503387b8d72a18</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.22071.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.22074.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>bd2a12f9cc6c93c249f987b42c1c761550369674</Sha>
+      <Sha>0137095821e2e5a9e030d97248503387b8d72a18</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="7.0.0-beta.22071.6">
+    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="7.0.0-beta.22074.13">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>e1ea8873d2e0175c1d1e49b3884cd2e9c6ef5007</Sha>
+      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
     </Dependency>
     <Dependency Name="optimization.windows_nt-x64.MIBC.Runtime" Version="1.0.0-prerelease.21577.2">
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
@@ -270,9 +270,9 @@
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
       <Sha>91d6b3c1f51888d166701510189505f35714665c</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.HotReload.Utils.Generator.BuildTool" Version="1.0.2-alpha.0.22069.1">
+    <Dependency Name="Microsoft.DotNet.HotReload.Utils.Generator.BuildTool" Version="1.0.2-alpha.0.22074.1">
       <Uri>https://github.com/dotnet/hotreload-utils</Uri>
-      <Sha>b6504c8dca937ff1a59d3283374241eacf26684a</Sha>
+      <Sha>d3e96c2e8ed4d58de217c44423c9ba3b90333724</Sha>
     </Dependency>
     <Dependency Name="System.Runtime.Numerics.TestData" Version="7.0.0-beta.22060.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 535f0f7e4f01e4..5beaf9c02f194a 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -54,21 +54,21 @@
     <!-- SDK dependencies -->
     <MicrosoftDotNetCompatibilityVersion>2.0.0-alpha.1.21525.11</MicrosoftDotNetCompatibilityVersion>
     <!-- Arcade dependencies -->
-    <MicrosoftDotNetApiCompatVersion>7.0.0-beta.22071.6</MicrosoftDotNetApiCompatVersion>
-    <MicrosoftDotNetBuildTasksFeedVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksFeedVersion>
-    <MicrosoftDotNetCodeAnalysisVersion>7.0.0-beta.22071.6</MicrosoftDotNetCodeAnalysisVersion>
-    <MicrosoftDotNetGenAPIVersion>7.0.0-beta.22071.6</MicrosoftDotNetGenAPIVersion>
-    <MicrosoftDotNetGenFacadesVersion>7.0.0-beta.22071.6</MicrosoftDotNetGenFacadesVersion>
-    <MicrosoftDotNetXUnitExtensionsVersion>7.0.0-beta.22071.6</MicrosoftDotNetXUnitExtensionsVersion>
-    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.22071.6</MicrosoftDotNetXUnitConsoleRunnerVersion>
-    <MicrosoftDotNetBuildTasksArchivesVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksArchivesVersion>
-    <MicrosoftDotNetBuildTasksInstallersVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksInstallersVersion>
-    <MicrosoftDotNetBuildTasksPackagingVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksPackagingVersion>
-    <MicrosoftDotNetBuildTasksTemplatingVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksTemplatingVersion>
-    <MicrosoftDotNetBuildTasksWorkloadsPackageVersion>7.0.0-beta.22071.6</MicrosoftDotNetBuildTasksWorkloadsPackageVersion>
-    <MicrosoftDotNetRemoteExecutorVersion>7.0.0-beta.22071.6</MicrosoftDotNetRemoteExecutorVersion>
-    <MicrosoftDotNetVersionToolsTasksVersion>7.0.0-beta.22071.6</MicrosoftDotNetVersionToolsTasksVersion>
-    <MicrosoftDotNetPackageTestingVersion>7.0.0-beta.22071.6</MicrosoftDotNetPackageTestingVersion>
+    <MicrosoftDotNetApiCompatVersion>7.0.0-beta.22074.13</MicrosoftDotNetApiCompatVersion>
+    <MicrosoftDotNetBuildTasksFeedVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksFeedVersion>
+    <MicrosoftDotNetCodeAnalysisVersion>7.0.0-beta.22074.13</MicrosoftDotNetCodeAnalysisVersion>
+    <MicrosoftDotNetGenAPIVersion>7.0.0-beta.22074.13</MicrosoftDotNetGenAPIVersion>
+    <MicrosoftDotNetGenFacadesVersion>7.0.0-beta.22074.13</MicrosoftDotNetGenFacadesVersion>
+    <MicrosoftDotNetXUnitExtensionsVersion>7.0.0-beta.22074.13</MicrosoftDotNetXUnitExtensionsVersion>
+    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.22074.13</MicrosoftDotNetXUnitConsoleRunnerVersion>
+    <MicrosoftDotNetBuildTasksArchivesVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksArchivesVersion>
+    <MicrosoftDotNetBuildTasksInstallersVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksInstallersVersion>
+    <MicrosoftDotNetBuildTasksPackagingVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksPackagingVersion>
+    <MicrosoftDotNetBuildTasksTemplatingVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksTemplatingVersion>
+    <MicrosoftDotNetBuildTasksWorkloadsPackageVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksWorkloadsPackageVersion>
+    <MicrosoftDotNetRemoteExecutorVersion>7.0.0-beta.22074.13</MicrosoftDotNetRemoteExecutorVersion>
+    <MicrosoftDotNetVersionToolsTasksVersion>7.0.0-beta.22074.13</MicrosoftDotNetVersionToolsTasksVersion>
+    <MicrosoftDotNetPackageTestingVersion>7.0.0-beta.22074.13</MicrosoftDotNetPackageTestingVersion>
     <!-- NuGet dependencies -->
     <NuGetBuildTasksPackVersion>6.0.0-preview.1.102</NuGetBuildTasksPackVersion>
     <!-- Installer dependencies -->
@@ -160,10 +160,10 @@
     <!-- Testing -->
     <MicrosoftNETCoreCoreDisToolsVersion>1.0.1-prerelease-00006</MicrosoftNETCoreCoreDisToolsVersion>
     <MicrosoftNETTestSdkVersion>16.9.0-preview-20201201-01</MicrosoftNETTestSdkVersion>
-    <MicrosoftDotNetXHarnessTestRunnersCommonVersion>1.0.0-prerelease.22071.1</MicrosoftDotNetXHarnessTestRunnersCommonVersion>
-    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.22071.1</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
-    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.22071.1</MicrosoftDotNetXHarnessCLIVersion>
-    <MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>1.0.2-alpha.0.22069.1</MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>
+    <MicrosoftDotNetXHarnessTestRunnersCommonVersion>1.0.0-prerelease.22074.1</MicrosoftDotNetXHarnessTestRunnersCommonVersion>
+    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.22074.1</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
+    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.22074.1</MicrosoftDotNetXHarnessCLIVersion>
+    <MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>1.0.2-alpha.0.22074.1</MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>
     <XUnitVersion>2.4.2-pre.22</XUnitVersion>
     <XUnitAnalyzersVersion>0.12.0-pre.20</XUnitAnalyzersVersion>
     <XUnitRunnerVisualStudioVersion>2.4.2</XUnitRunnerVisualStudioVersion>
@@ -180,18 +180,18 @@
     <MicrosoftNETILLinkTasksVersion>7.0.100-1.22063.2</MicrosoftNETILLinkTasksVersion>
     <MicrosoftNETILLinkAnalyzerPackageVersion>$(MicrosoftNETILLinkTasksVersion)</MicrosoftNETILLinkAnalyzerPackageVersion>
     <!-- ICU -->
-    <MicrosoftNETCoreRuntimeICUTransportVersion>7.0.0-preview.2.22071.2</MicrosoftNETCoreRuntimeICUTransportVersion>
+    <MicrosoftNETCoreRuntimeICUTransportVersion>7.0.0-preview.2.22074.5</MicrosoftNETCoreRuntimeICUTransportVersion>
     <!-- MsQuic -->
     <SystemNetMsQuicTransportVersion>7.0.0-alpha.1.21529.3</SystemNetMsQuicTransportVersion>
     <!-- Mono LLVM -->
-    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22067.2</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22067.2</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
-    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22067.2</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22067.2</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
-    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22067.2</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22067.2</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
-    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22067.2</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
-    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22067.2</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22074.2</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22074.2</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22074.2</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22074.2</runtimelinuxx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22074.2</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22074.2</runtimewinx64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
+    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>11.1.0-alpha.1.22074.2</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
+    <runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>11.1.0-alpha.1.22074.2</runtimeosx1012x64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>
     <!-- emscripten / Node -->
     <MicrosoftNETWorkloadEmscriptenManifest70100Version>7.0.0-alpha.2.22071.3</MicrosoftNETWorkloadEmscriptenManifest70100Version>
     <MicrosoftNETRuntimeEmscriptenVersion>$(MicrosoftNETWorkloadEmscriptenManifest70100Version)</MicrosoftNETRuntimeEmscriptenVersion>
diff --git a/eng/common/templates/job/execute-sdl.yml b/eng/common/templates/job/execute-sdl.yml
index a4837c32c3869c..24cec0424e5d64 100644
--- a/eng/common/templates/job/execute-sdl.yml
+++ b/eng/common/templates/job/execute-sdl.yml
@@ -47,8 +47,14 @@ jobs:
     - name: GuardianVersion
       value: ${{ coalesce(parameters.overrideGuardianVersion, '$(DefaultGuardianVersion)') }}
   pool:
-    name: NetCore1ESPool-Internal
-    demands: ImageOverride -equals Build.Server.Amd64.VS2019
+    # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+    ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+      name: VSEngSS-MicroBuild2022-1ES
+      demands: Cmd
+    # If it's not devdiv, it's dnceng
+    ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+      name: NetCore1ESPool-Internal
+      demands: ImageOverride -equals Build.Server.Amd64.VS2019
   steps:
   - checkout: self
     clean: true
diff --git a/eng/common/templates/job/onelocbuild.yml b/eng/common/templates/job/onelocbuild.yml
index 0b93fd5b490ebb..9d1e3042d8a6c0 100644
--- a/eng/common/templates/job/onelocbuild.yml
+++ b/eng/common/templates/job/onelocbuild.yml
@@ -3,10 +3,8 @@ parameters:
   dependsOn: ''
 
   # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
-  pool:
-    name: NetCore1ESPool-Internal
-    demands: ImageOverride -equals Build.Server.Amd64.VS2019
-
+  pool: ''
+    
   CeapexPat: $(dn-bot-ceapex-package-r) # PAT for the loc AzDO instance https://dev.azure.com/ceapex
   GithubPat: $(BotAccount-dotnet-bot-repo-PAT)
 
@@ -32,7 +30,18 @@ jobs:
 
   displayName: OneLocBuild
 
-  pool: ${{ parameters.pool }}
+  ${{ if ne(parameters.pool, '') }}:
+    pool: ${{ parameters.pool }}
+  ${{ if eq(parameters.pool, '') }}:
+    pool:
+      # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+      ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+        name: VSEngSS-MicroBuild2022-1ES
+        demands: Cmd
+      # If it's not devdiv, it's dnceng
+      ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+        name: NetCore1ESPool-Internal
+        demands: ImageOverride -equals Build.Server.Amd64.VS2019
 
   variables:
     - group: OneLocBuildVariables # Contains the CeapexPat and GithubPat
diff --git a/eng/common/templates/jobs/jobs.yml b/eng/common/templates/jobs/jobs.yml
index dafa603dc5d900..554e71cfc436dd 100644
--- a/eng/common/templates/jobs/jobs.yml
+++ b/eng/common/templates/jobs/jobs.yml
@@ -83,8 +83,14 @@ jobs:
         - ${{ if eq(parameters.enableSourceBuild, true) }}:
           - Source_Build_Complete
         pool:
-          name: NetCore1ESPool-Internal
-          demands: ImageOverride -equals Build.Server.Amd64.VS2019
+          # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+          ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+            name: VSEngSS-MicroBuild2022-1ES
+            demands: Cmd
+          # If it's not devdiv, it's dnceng
+          ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+            name: NetCore1ESPool-Internal
+            demands: ImageOverride -equals Build.Server.Amd64.VS2019
 
         runAsPublic: ${{ parameters.runAsPublic }}
         publishUsingPipelines: ${{ parameters.enablePublishUsingPipelines }}
diff --git a/eng/common/templates/post-build/post-build.yml b/eng/common/templates/post-build/post-build.yml
index 9583d27dbbf89d..2f176571f020cf 100644
--- a/eng/common/templates/post-build/post-build.yml
+++ b/eng/common/templates/post-build/post-build.yml
@@ -94,8 +94,14 @@ stages:
       displayName: NuGet Validation
       condition: eq( ${{ parameters.enableNugetValidation }}, 'true')
       pool:
-        name: NetCore1ESPool-Internal
-        demands: ImageOverride -equals Build.Server.Amd64.VS2019
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: VSEngSS-MicroBuild2022-1ES
+          demands: Cmd
+        # If it's not devdiv, it's dnceng
+        ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+          name: NetCore1ESPool-Internal
+          demands: ImageOverride -equals Build.Server.Amd64.VS2019
 
       steps:
         - template: setup-maestro-vars.yml
@@ -125,8 +131,14 @@ stages:
       displayName: Signing Validation
       condition: and( eq( ${{ parameters.enableSigningValidation }}, 'true'), ne( variables['PostBuildSign'], 'true'))
       pool:
-        name: NetCore1ESPool-Internal
-        demands: ImageOverride -equals Build.Server.Amd64.VS2019
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: VSEngSS-MicroBuild2022-1ES
+          demands: Cmd
+        # If it's not devdiv, it's dnceng
+        ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+          name: NetCore1ESPool-Internal
+          demands: ImageOverride -equals Build.Server.Amd64.VS2019
       steps:
         - template: setup-maestro-vars.yml
           parameters:
@@ -179,8 +191,14 @@ stages:
       displayName: SourceLink Validation
       condition: eq( ${{ parameters.enableSourceLinkValidation }}, 'true')
       pool:
-        name: NetCore1ESPool-Internal
-        demands: ImageOverride -equals Build.Server.Amd64.VS2019
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: VSEngSS-MicroBuild2022-1ES
+          demands: Cmd
+        # If it's not devdiv, it's dnceng
+        ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+          name: NetCore1ESPool-Internal
+          demands: ImageOverride -equals Build.Server.Amd64.VS2019
       steps:
         - template: setup-maestro-vars.yml
           parameters:
@@ -230,14 +248,22 @@ stages:
     displayName: Publish Using Darc
     timeoutInMinutes: 120
     pool:
-      name: NetCore1ESPool-Internal
-      demands: ImageOverride -equals Build.Server.Amd64.VS2019
+      # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: VSEngSS-MicroBuild2022-1ES
+          demands: Cmd
+        # If it's not devdiv, it's dnceng
+        ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+          name: NetCore1ESPool-Internal
+          demands: ImageOverride -equals Build.Server.Amd64.VS2019
     steps:
       - template: setup-maestro-vars.yml
         parameters:
           BARBuildId: ${{ parameters.BARBuildId }}
           PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
 
+      - task: NuGetAuthenticate@0
+
       - task: PowerShell@2
         displayName: Publish Using Darc
         inputs:
diff --git a/eng/common/templates/post-build/setup-maestro-vars.yml b/eng/common/templates/post-build/setup-maestro-vars.yml
index 826d3ed5f74c20..0c87f149a4ad77 100644
--- a/eng/common/templates/post-build/setup-maestro-vars.yml
+++ b/eng/common/templates/post-build/setup-maestro-vars.yml
@@ -16,6 +16,7 @@ steps:
     displayName: Set Release Configs Vars
     inputs:
       targetType: inline
+      pwsh: true
       script: |
         try {
           if (!$Env:PromoteToMaestroChannels -or $Env:PromoteToMaestroChannels.Trim() -eq '') {
diff --git a/global.json b/global.json
index f32ffc29ff09d7..c6832999bdb02a 100644
--- a/global.json
+++ b/global.json
@@ -12,10 +12,10 @@
     "python3": "3.7.1"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "7.0.0-beta.22071.6",
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22071.6",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22071.6",
-    "Microsoft.DotNet.SharedFramework.Sdk": "7.0.0-beta.22071.6",
+    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "7.0.0-beta.22074.13",
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22074.13",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22074.13",
+    "Microsoft.DotNet.SharedFramework.Sdk": "7.0.0-beta.22074.13",
     "Microsoft.Build.NoTargets": "3.1.0",
     "Microsoft.Build.Traversal": "3.0.23",
     "Microsoft.NET.Sdk.IL": "7.0.0-alpha.1.22073.5"

From 7483b24b73a962bdf8e7be8426a7b43ba4ff09de Mon Sep 17 00:00:00 2001
From: Bradley Grainger <bgrainger@gmail.com>
Date: Tue, 25 Jan 2022 12:02:24 -0800
Subject: [PATCH 067/161] Add CancellationToken to TextReader.ReadXAsync
 (#61898)

Co-authored-by: Adam Sitnik <adam.sitnik@gmail.com>
Co-authored-by: Stephen Toub <stoub@microsoft.com>
---
 .../src/System/IO/SyncTextReader.cs           | 15 ++++
 .../tests/StreamReader/StreamReaderTests.cs   | 59 ++++++++++++++
 .../StringReader/StringReader.CtorTests.cs    | 27 +++++++
 .../tests/TextReader/TextReaderTests.cs       | 21 +++++
 .../src/System/IO/File.cs                     |  2 +-
 .../src/System/IO/StreamReader.cs             | 81 ++++++++++++++++---
 .../src/System/IO/StringReader.cs             | 63 +++++++++++++++
 .../src/System/IO/TextReader.cs               | 56 +++++++++++--
 .../System.Runtime/ref/System.Runtime.cs      |  6 ++
 9 files changed, 311 insertions(+), 19 deletions(-)

diff --git a/src/libraries/System.Console/src/System/IO/SyncTextReader.cs b/src/libraries/System.Console/src/System/IO/SyncTextReader.cs
index 7a2661691e6247..33ef898edb688c 100644
--- a/src/libraries/System.Console/src/System/IO/SyncTextReader.cs
+++ b/src/libraries/System.Console/src/System/IO/SyncTextReader.cs
@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace System.IO
@@ -95,11 +96,25 @@ public override string ReadToEnd()
             return Task.FromResult(ReadLine());
         }
 
+        public override ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken)
+        {
+            return cancellationToken.IsCancellationRequested ?
+                ValueTask.FromCanceled<string?>(cancellationToken) :
+                new ValueTask<string?>(ReadLine());
+        }
+
         public override Task<string> ReadToEndAsync()
         {
             return Task.FromResult(ReadToEnd());
         }
 
+        public override Task<string> ReadToEndAsync(CancellationToken cancellationToken)
+        {
+            return cancellationToken.IsCancellationRequested ?
+                Task.FromCanceled<string>(cancellationToken) :
+                Task.FromResult(ReadToEnd());
+        }
+
         public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
         {
             if (buffer == null)
diff --git a/src/libraries/System.IO/tests/StreamReader/StreamReaderTests.cs b/src/libraries/System.IO/tests/StreamReader/StreamReaderTests.cs
index 4a2b91f8862b57..fccc269868ed7e 100644
--- a/src/libraries/System.IO/tests/StreamReader/StreamReaderTests.cs
+++ b/src/libraries/System.IO/tests/StreamReader/StreamReaderTests.cs
@@ -110,6 +110,44 @@ public async Task ReadToEndAsync()
             Assert.Equal(5000, result.Length);
         }
 
+        [Fact]
+        public async Task ReadToEndAsync_WithCancellationToken()
+        {
+            using var sw = new StreamReader(GetLargeStream());
+            var result = await sw.ReadToEndAsync(default);
+
+            Assert.Equal(5000, result.Length);
+        }
+
+        [Fact]
+        public async Task ReadToEndAsync_WithCanceledCancellationToken()
+        {
+            using var sw = new StreamReader(GetLargeStream());
+            using var cts = new CancellationTokenSource();
+            cts.Cancel();
+            var token = cts.Token;
+
+            var ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await sw.ReadToEndAsync(token));
+            Assert.Equal(token, ex.CancellationToken);
+        }
+
+        [Fact]
+        [SkipOnPlatform(TestPlatforms.Browser, "Not supported on Browser.")]
+        public async Task ReadToEndAsync_WithCancellation()
+        {
+            string path = GetTestFilePath();
+            
+            // create large (~100MB) file
+            File.WriteAllLines(path, Enumerable.Repeat("A very large file used for testing StreamReader cancellation. 0123456789012345678901234567890123456789.", 1_000_000));
+
+            using StreamReader reader = File.OpenText(path);
+            using CancellationTokenSource cts = new (TimeSpan.FromMilliseconds(50));
+            var token = cts.Token;
+
+            var ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await reader.ReadToEndAsync(token));
+            Assert.Equal(token, ex.CancellationToken);
+        }
+
         [Fact]
         public void GetBaseStream()
         {
@@ -301,6 +339,27 @@ public void VanillaReadLines2()
             Assert.Equal(valueString.Substring(1, valueString.IndexOf('\r') - 1), data);
         }
 
+        [Fact]
+        public async Task VanillaReadLineAsync()
+        {
+            var baseInfo = GetCharArrayStream();
+            var sr = baseInfo.Item2;
+
+            string valueString = new string(baseInfo.Item1);
+
+            var data = await sr.ReadLineAsync();
+            Assert.Equal(valueString.Substring(0, valueString.IndexOf('\r')), data);
+
+            data = await sr.ReadLineAsync(default);
+            Assert.Equal(valueString.Substring(valueString.IndexOf('\r') + 1, 3), data);
+
+            data = await sr.ReadLineAsync();
+            Assert.Equal(valueString.Substring(valueString.IndexOf('\n') + 1, 2), data);
+
+            data = await sr.ReadLineAsync(default);
+            Assert.Equal((valueString.Substring(valueString.LastIndexOf('\n') + 1)), data);
+        }
+
         [Fact]
         public async Task ContinuousNewLinesAndTabsAsync()
         {
diff --git a/src/libraries/System.IO/tests/StringReader/StringReader.CtorTests.cs b/src/libraries/System.IO/tests/StringReader/StringReader.CtorTests.cs
index 9e500923164f38..3c4446f07f47a7 100644
--- a/src/libraries/System.IO/tests/StringReader/StringReader.CtorTests.cs
+++ b/src/libraries/System.IO/tests/StringReader/StringReader.CtorTests.cs
@@ -68,6 +68,23 @@ public static void ReadLine()
             }
         }
 
+        [Fact]
+        public static async Task ReadLineAsync()
+        {
+            string str1 = "Hello\0\t\v   \\ World";
+            string str2 = str1 + Environment.NewLine + str1;
+
+            using (StringReader sr = new StringReader(str1))
+            {
+                Assert.Equal(str1, await sr.ReadLineAsync());
+            }
+            using (StringReader sr = new StringReader(str2))
+            {
+                Assert.Equal(str1, await sr.ReadLineAsync(default));
+                Assert.Equal(str1, await sr.ReadLineAsync(default));
+            }
+        }
+
         [Fact]
         public static void ReadPseudoRandomString()
         {
@@ -155,6 +172,14 @@ public static void ReadToEndPseudoRandom() {
             Assert.Equal(str1, sr.ReadToEnd());
         }
 
+        [Fact]
+        public static async Task ReadToEndAsyncString()
+        {
+            string str1 = "Hello\0\t\v   \\ World";
+            StringReader sr = new StringReader(str1);
+            Assert.Equal(str1, await sr.ReadToEndAsync(default));
+        }
+
         [Fact]
         public static void Closed_DisposedExceptions()
         {
@@ -278,6 +303,8 @@ public async Task Precanceled_ThrowsException()
 
             await Assert.ThrowsAnyAsync<OperationCanceledException>(() => reader.ReadAsync(Memory<char>.Empty, new CancellationToken(true)).AsTask());
             await Assert.ThrowsAnyAsync<OperationCanceledException>(() => reader.ReadBlockAsync(Memory<char>.Empty, new CancellationToken(true)).AsTask());
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => reader.ReadLineAsync(new CancellationToken(true)).AsTask());
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => reader.ReadToEndAsync(new CancellationToken(true)));
         }
 
         private static void ValidateDisposedExceptions(StringReader sr)
diff --git a/src/libraries/System.IO/tests/TextReader/TextReaderTests.cs b/src/libraries/System.IO/tests/TextReader/TextReaderTests.cs
index e6ba6d818f2867..48f83d7108e53d 100644
--- a/src/libraries/System.IO/tests/TextReader/TextReaderTests.cs
+++ b/src/libraries/System.IO/tests/TextReader/TextReaderTests.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -54,6 +55,26 @@ public async Task ReadToEndAsync()
             }
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        public async Task ReadToEndAsync_WithCancellationToken()
+        {
+            using var tr = new CharArrayTextReader(TestDataProvider.LargeData);
+            var result = await tr.ReadToEndAsync(default);
+            Assert.Equal(5000, result.Length);
+        }
+
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        public async Task ReadToEndAsync_WithCanceledCancellationToken()
+        {
+            using var tr = new CharArrayTextReader(TestDataProvider.LargeData);
+            using var cts = new CancellationTokenSource();
+            cts.Cancel();
+            var token = cts.Token;
+
+            var ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await tr.ReadToEndAsync(token));
+            Assert.Equal(token, ex.CancellationToken);
+        }
+
         [Fact]
         public void TestRead()
         {
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/File.cs b/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
index 2b4c61f1eb0baa..007a16d590b0aa 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
@@ -649,7 +649,7 @@ private static async Task<string[]> InternalReadAllLinesAsync(string path, Encod
                 cancellationToken.ThrowIfCancellationRequested();
                 string? line;
                 List<string> lines = new List<string>();
-                while ((line = await sr.ReadLineAsync().ConfigureAwait(false)) != null)
+                while ((line = await sr.ReadLineAsync(cancellationToken).ConfigureAwait(false)) != null)
                 {
                     lines.Add(line);
                     cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs b/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
index 3b3e03a806ff54..b5aca3d1dfbcf7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
@@ -845,7 +845,37 @@ private int ReadBuffer(Span<char> userBuffer, out bool readToUserBuffer)
             return sb.ToString();
         }
 
-        public override Task<string?> ReadLineAsync()
+        public override Task<string?> ReadLineAsync() =>
+            ReadLineAsync(default).AsTask();
+
+        /// <summary>
+        /// Reads a line of characters asynchronously from the current stream and returns the data as a string.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A value task that represents the asynchronous read operation. The value of the <c>TResult</c>
+        /// parameter contains the next line from the stream, or is <see langword="null" /> if all of the characters have been read.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The number of characters in the next line is larger than <see cref="int.MaxValue"/>.</exception>
+        /// <exception cref="ObjectDisposedException">The stream reader has been disposed.</exception>
+        /// <exception cref="InvalidOperationException">The reader is currently in use by a previous read operation.</exception>
+        /// <example>
+        /// The following example shows how to read and print all lines from the file until the end of the file is reached or the operation timed out.
+        /// <code lang="C#">
+        /// using CancellationTokenSource tokenSource = new (TimeSpan.FromSeconds(1));
+        /// using StreamReader reader = File.OpenText("existingfile.txt");
+        ///
+        /// string line;
+        /// while ((line = await reader.ReadLineAsync(tokenSource.Token)) is not null)
+        /// {
+        ///     Console.WriteLine(line);
+        /// }
+        /// </code>
+        /// </example>
+        /// <remarks>
+        /// If this method is canceled via <paramref name="cancellationToken"/>, some data
+        /// that has been read from the current <see cref="Stream"/> but not stored (by the
+        /// <see cref="StreamReader"/>) or returned (to the caller) may be lost.
+        /// </remarks>
+        public override ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken)
         {
             // If we have been inherited into a subclass, the following implementation could be incorrect
             // since it does not call through to Read() which a subclass might have overridden.
@@ -853,21 +883,21 @@ private int ReadBuffer(Span<char> userBuffer, out bool readToUserBuffer)
             // and delegate to our base class (which will call into Read) when we are not sure.
             if (GetType() != typeof(StreamReader))
             {
-                return base.ReadLineAsync();
+                return base.ReadLineAsync(cancellationToken);
             }
 
             ThrowIfDisposed();
             CheckAsyncTaskInProgress();
 
-            Task<string?> task = ReadLineAsyncInternal();
+            Task<string?> task = ReadLineAsyncInternal(cancellationToken);
             _asyncReadTask = task;
 
-            return task;
+            return new ValueTask<string?>(task);
         }
 
-        private async Task<string?> ReadLineAsyncInternal()
+        private async Task<string?> ReadLineAsyncInternal(CancellationToken cancellationToken)
         {
-            if (_charPos == _charLen && (await ReadBufferAsync(CancellationToken.None).ConfigureAwait(false)) == 0)
+            if (_charPos == _charLen && (await ReadBufferAsync(cancellationToken).ConfigureAwait(false)) == 0)
             {
                 return null;
             }
@@ -903,7 +933,7 @@ private int ReadBuffer(Span<char> userBuffer, out bool readToUserBuffer)
 
                         _charPos = tmpCharPos = i + 1;
 
-                        if (ch == '\r' && (tmpCharPos < tmpCharLen || (await ReadBufferAsync(CancellationToken.None).ConfigureAwait(false)) > 0))
+                        if (ch == '\r' && (tmpCharPos < tmpCharLen || (await ReadBufferAsync(cancellationToken).ConfigureAwait(false)) > 0))
                         {
                             tmpCharPos = _charPos;
                             if (_charBuffer[tmpCharPos] == '\n')
@@ -921,12 +951,37 @@ private int ReadBuffer(Span<char> userBuffer, out bool readToUserBuffer)
                 i = tmpCharLen - tmpCharPos;
                 sb ??= new StringBuilder(i + 80);
                 sb.Append(tmpCharBuffer, tmpCharPos, i);
-            } while (await ReadBufferAsync(CancellationToken.None).ConfigureAwait(false) > 0);
+            } while (await ReadBufferAsync(cancellationToken).ConfigureAwait(false) > 0);
 
             return sb.ToString();
         }
 
-        public override Task<string> ReadToEndAsync()
+        public override Task<string> ReadToEndAsync() => ReadToEndAsync(default);
+
+        /// <summary>
+        /// Reads all characters from the current position to the end of the stream asynchronously and returns them as one string.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A task that represents the asynchronous read operation. The value of the <c>TResult</c> parameter contains
+        /// a string with the characters from the current position to the end of the stream.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The number of characters is larger than <see cref="int.MaxValue"/>.</exception>
+        /// <exception cref="ObjectDisposedException">The stream reader has been disposed.</exception>
+        /// <exception cref="InvalidOperationException">The reader is currently in use by a previous read operation.</exception>
+        /// <example>
+        /// The following example shows how to read the contents of a file by using the <see cref="ReadToEndAsync(CancellationToken)"/> method.
+        /// <code lang="C#">
+        /// using CancellationTokenSource tokenSource = new (TimeSpan.FromSeconds(1));
+        /// using StreamReader reader = File.OpenText("existingfile.txt");
+        ///
+        /// Console.WriteLine(await reader.ReadToEndAsync(tokenSource.Token));
+        /// </code>
+        /// </example>
+        /// <remarks>
+        /// If this method is canceled via <paramref name="cancellationToken"/>, some data
+        /// that has been read from the current <see cref="Stream"/> but not stored (by the
+        /// <see cref="StreamReader"/>) or returned (to the caller) may be lost.
+        /// </remarks>
+        public override Task<string> ReadToEndAsync(CancellationToken cancellationToken)
         {
             // If we have been inherited into a subclass, the following implementation could be incorrect
             // since it does not call through to Read() which a subclass might have overridden.
@@ -934,19 +989,19 @@ public override Task<string> ReadToEndAsync()
             // and delegate to our base class (which will call into Read) when we are not sure.
             if (GetType() != typeof(StreamReader))
             {
-                return base.ReadToEndAsync();
+                return base.ReadToEndAsync(cancellationToken);
             }
 
             ThrowIfDisposed();
             CheckAsyncTaskInProgress();
 
-            Task<string> task = ReadToEndAsyncInternal();
+            Task<string> task = ReadToEndAsyncInternal(cancellationToken);
             _asyncReadTask = task;
 
             return task;
         }
 
-        private async Task<string> ReadToEndAsyncInternal()
+        private async Task<string> ReadToEndAsyncInternal(CancellationToken cancellationToken)
         {
             // Call ReadBuffer, then pull data out of charBuffer.
             StringBuilder sb = new StringBuilder(_charLen - _charPos);
@@ -955,7 +1010,7 @@ private async Task<string> ReadToEndAsyncInternal()
                 int tmpCharPos = _charPos;
                 sb.Append(_charBuffer, tmpCharPos, _charLen - tmpCharPos);
                 _charPos = _charLen;  // We consumed these characters
-                await ReadBufferAsync(CancellationToken.None).ConfigureAwait(false);
+                await ReadBufferAsync(cancellationToken).ConfigureAwait(false);
             } while (_charLen > 0);
 
             return sb.ToString();
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/StringReader.cs b/src/libraries/System.Private.CoreLib/src/System/IO/StringReader.cs
index 3d50897ec7f386..a8e07ad382d151 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/StringReader.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/StringReader.cs
@@ -224,11 +224,74 @@ public override string ReadToEnd()
             return Task.FromResult(ReadLine());
         }
 
+        /// <summary>
+        /// Reads a line of characters asynchronously from the current string and returns the data as a string.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A value task that represents the asynchronous read operation. The value of the <c>TResult</c>
+        /// parameter contains the next line from the string reader, or is <see langword="null" /> if all of the characters have been read.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The number of characters in the next line is larger than <see cref="int.MaxValue"/>.</exception>
+        /// <exception cref="ObjectDisposedException">The string reader has been disposed.</exception>
+        /// <exception cref="InvalidOperationException">The reader is currently in use by a previous read operation.</exception>
+        /// <example>
+        /// The following example shows how to read one line at a time from a string asynchronously.
+        /// <code lang="C#">
+        /// using System.Text;
+        ///
+        /// StringBuilder stringToRead = new();
+        /// stringToRead.AppendLine("Characters in 1st line to read");
+        /// stringToRead.AppendLine("and 2nd line");
+        /// stringToRead.AppendLine("and the end");
+        ///
+        /// string readText;
+        /// using CancellationTokenSource tokenSource = new (TimeSpan.FromSeconds(1));
+        /// using StringReader reader = new (stringToRead.ToString());
+        /// while ((readText = await reader.ReadLineAsync(tokenSource.Token)) is not null)
+        /// {
+        ///     Console.WriteLine(readText);
+        /// }
+        /// </code>
+        /// </example>
+        public override ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken) =>
+            cancellationToken.IsCancellationRequested
+                ? ValueTask.FromCanceled<string?>(cancellationToken)
+                : new ValueTask<string?>(ReadLine());
+
         public override Task<string> ReadToEndAsync()
         {
             return Task.FromResult(ReadToEnd());
         }
 
+        /// <summary>
+        /// Reads all characters from the current position to the end of the string asynchronously and returns them as a single string.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A task that represents the asynchronous read operation. The value of the <c>TResult</c> parameter contains
+        /// a string with the characters from the current position to the end of the string.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The number of characters is larger than <see cref="int.MaxValue"/>.</exception>
+        /// <exception cref="ObjectDisposedException">The string reader has been disposed.</exception>
+        /// <exception cref="InvalidOperationException">The reader is currently in use by a previous read operation.</exception>
+        /// <example>
+        /// The following example shows how to read an entire string asynchronously.
+        /// <code lang="C#">
+        /// using System.Text;
+        ///
+        /// StringBuilder stringToRead = new();
+        /// stringToRead.AppendLine("Characters in 1st line to read");
+        /// stringToRead.AppendLine("and 2nd line");
+        /// stringToRead.AppendLine("and the end");
+        ///
+        /// using CancellationTokenSource tokenSource = new (TimeSpan.FromSeconds(1));
+        /// using StringReader reader = new (stringToRead.ToString());
+        /// var readText = await reader.ReadToEndAsync(tokenSource.Token);
+        /// Console.WriteLine(readText);
+        /// </code>
+        /// </example>
+        public override Task<string> ReadToEndAsync(CancellationToken cancellationToken) =>
+            cancellationToken.IsCancellationRequested
+                ? Task.FromCanceled<string>(cancellationToken)
+                : Task.FromResult(ReadToEnd());
+
         public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
         {
             if (buffer == null)
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs b/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs
index 05211d6dc7a331..583fb3c2652ae6 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs
@@ -203,18 +203,56 @@ public virtual int ReadBlock(Span<char> buffer)
         }
 
         #region Task based Async APIs
-        public virtual Task<string?> ReadLineAsync() =>
+        public virtual Task<string?> ReadLineAsync() => ReadLineCoreAsync(default);
+
+        /// <summary>
+        /// Reads a line of characters asynchronously and returns the data as a string.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A value task that represents the asynchronous read operation. The value of the <c>TResult</c>
+        /// parameter contains the next line from the text reader, or is <see langword="null" /> if all of the characters have been read.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The number of characters in the next line is larger than <see cref="int.MaxValue"/>.</exception>
+        /// <exception cref="ObjectDisposedException">The text reader has been disposed.</exception>
+        /// <exception cref="InvalidOperationException">The reader is currently in use by a previous read operation.</exception>
+        /// <remarks>
+        /// <para>The <see cref="TextReader"/> class is an abstract class. Therefore, you do not instantiate it in
+        /// your code. For an example of using the <see cref="ReadLineAsync(CancellationToken)"/> method, see the
+        /// <see cref="StreamReader.ReadLineAsync(CancellationToken)"/> method.</para>
+        /// <para>If the current <see cref="TextReader"/> represents the standard input stream returned by
+        /// the <c>Console.In</c> property, the <see cref="ReadLineAsync(CancellationToken)"/> method
+        /// executes synchronously rather than asynchronously.</para>
+        /// </remarks>
+        public virtual ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken) =>
+            new ValueTask<string?>(ReadLineCoreAsync(cancellationToken));
+
+        private Task<string?> ReadLineCoreAsync(CancellationToken cancellationToken) =>
             Task<string?>.Factory.StartNew(static state => ((TextReader)state!).ReadLine(), this,
-                CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
-
-        public virtual async Task<string> ReadToEndAsync()
+                cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+
+        public virtual Task<string> ReadToEndAsync() => ReadToEndAsync(default);
+
+        /// <summary>
+        /// Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A task that represents the asynchronous read operation. The value of the <c>TResult</c> parameter contains
+        /// a string with the characters from the current position to the end of the text reader.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The number of characters is larger than <see cref="int.MaxValue"/>.</exception>
+        /// <exception cref="ObjectDisposedException">The text reader has been disposed.</exception>
+        /// <exception cref="InvalidOperationException">The reader is currently in use by a previous read operation.</exception>
+        /// <remarks>
+        /// <para>The <see cref="TextReader"/> class is an abstract class. Therefore, you do not instantiate it in
+        /// your code. For an example of using the <see cref="ReadToEndAsync(CancellationToken)"/> method, see the
+        /// <see cref="StreamReader.ReadToEndAsync(CancellationToken)"/> method.</para>
+        /// </remarks>
+        public virtual async Task<string> ReadToEndAsync(CancellationToken cancellationToken)
         {
             var sb = new StringBuilder(4096);
             char[] chars = ArrayPool<char>.Shared.Rent(4096);
             try
             {
                 int len;
-                while ((len = await ReadAsyncInternal(chars, default).ConfigureAwait(false)) != 0)
+                while ((len = await ReadAsyncInternal(chars, cancellationToken).ConfigureAwait(false)) != 0)
                 {
                     sb.Append(chars, 0, len);
                 }
@@ -368,9 +406,17 @@ protected override void Dispose(bool disposing)
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override Task<string?> ReadLineAsync() => Task.FromResult(ReadLine());
 
+            [MethodImpl(MethodImplOptions.Synchronized)]
+            public override ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken)
+                => cancellationToken.IsCancellationRequested ? ValueTask.FromCanceled<string?>(cancellationToken) : new ValueTask<string?>(ReadLine());
+
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override Task<string> ReadToEndAsync() => Task.FromResult(ReadToEnd());
 
+            [MethodImpl(MethodImplOptions.Synchronized)]
+            public override Task<string> ReadToEndAsync(CancellationToken cancellationToken)
+                => cancellationToken.IsCancellationRequested ? Task.FromCanceled<string>(cancellationToken) : Task.FromResult(ReadToEnd());
+
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
             {
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index b8b136aeb3b5a7..82211a2cca7c8d 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -10868,8 +10868,10 @@ protected override void Dispose(bool disposing) { }
         public override System.Threading.Tasks.ValueTask<int> ReadBlockAsync(System.Memory<char> buffer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public override string? ReadLine() { throw null; }
         public override System.Threading.Tasks.Task<string?> ReadLineAsync() { throw null; }
+        public override System.Threading.Tasks.ValueTask<string?> ReadLineAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
         public override string ReadToEnd() { throw null; }
         public override System.Threading.Tasks.Task<string> ReadToEndAsync() { throw null; }
+        public override System.Threading.Tasks.Task<string> ReadToEndAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
     }
     public partial class StreamWriter : System.IO.TextWriter
     {
@@ -10933,8 +10935,10 @@ protected override void Dispose(bool disposing) { }
         public override System.Threading.Tasks.ValueTask<int> ReadBlockAsync(System.Memory<char> buffer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public override string? ReadLine() { throw null; }
         public override System.Threading.Tasks.Task<string?> ReadLineAsync() { throw null; }
+        public override System.Threading.Tasks.ValueTask<string?> ReadLineAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
         public override string ReadToEnd() { throw null; }
         public override System.Threading.Tasks.Task<string> ReadToEndAsync() { throw null; }
+        public override System.Threading.Tasks.Task<string> ReadToEndAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
     }
     public partial class StringWriter : System.IO.TextWriter
     {
@@ -10985,8 +10989,10 @@ protected virtual void Dispose(bool disposing) { }
         public virtual System.Threading.Tasks.ValueTask<int> ReadBlockAsync(System.Memory<char> buffer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public virtual string? ReadLine() { throw null; }
         public virtual System.Threading.Tasks.Task<string?> ReadLineAsync() { throw null; }
+        public virtual System.Threading.Tasks.ValueTask<string?> ReadLineAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
         public virtual string ReadToEnd() { throw null; }
         public virtual System.Threading.Tasks.Task<string> ReadToEndAsync() { throw null; }
+        public virtual System.Threading.Tasks.Task<string> ReadToEndAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
         public static System.IO.TextReader Synchronized(System.IO.TextReader reader) { throw null; }
     }
     public abstract partial class TextWriter : System.MarshalByRefObject, System.IAsyncDisposable, System.IDisposable

From fb284a84f4175bbcc88a89cef72a63a39d73f64e Mon Sep 17 00:00:00 2001
From: Jo Shields <directhex@apebox.org>
Date: Tue, 25 Jan 2022 15:09:34 -0500
Subject: [PATCH 068/161] Restrict parallelism in LLVM FullAOT compile, to
 prevent OOM (#63800)

* Restrict parallelism in FullAOT compile, to prevent OOM

* Reduce parallelism further, due to more OOM
---
 eng/pipelines/common/templates/runtimes/run-test-job.yml | 2 +-
 eng/pipelines/runtime.yml                                | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/eng/pipelines/common/templates/runtimes/run-test-job.yml b/eng/pipelines/common/templates/runtimes/run-test-job.yml
index 6aa8a54f24c0f8..f944ad47ba2037 100644
--- a/eng/pipelines/common/templates/runtimes/run-test-job.yml
+++ b/eng/pipelines/common/templates/runtimes/run-test-job.yml
@@ -319,7 +319,7 @@ jobs:
         - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(logRootNameArg)MonoAot $(monoAotBuildshCommand) $(buildConfig) $(archType) $(runtimeVariantArg)
           displayName: "LLVM AOT compile CoreCLR tests"
       - ${{ if eq(parameters.archType, 'arm64') }}:
-        - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(logRootNameArg)MonoAot $(monoAotBuildshCommand) $(buildConfig) $(archType) cross $(runtimeVariantArg)
+        - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(logRootNameArg)MonoAot $(monoAotBuildshCommand) $(buildConfig) $(archType) cross $(runtimeVariantArg) -maxcpucount:2
           displayName: "LLVM AOT cross-compile CoreCLR tests"
           env:
             __MonoToolPrefix: aarch64-linux-gnu-
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index 7fb2493bac4790..1c376cad61b93e 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -1110,8 +1110,7 @@ jobs:
     runtimeFlavor: mono
     platforms:
     - Linux_x64
-    # Disabled pending outcome of https://github.com/dotnet/runtime/issues/60234 investigation
-    #- Linux_arm64
+    - Linux_arm64
     helixQueueGroup: pr
     helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
     jobParameters:

From 33940e671a16ca558cc9d145369e16fd0ae2132e Mon Sep 17 00:00:00 2001
From: Vladimir Sadov <vsadov@microsoft.com>
Date: Tue, 25 Jan 2022 13:10:05 -0800
Subject: [PATCH 069/161] Moved AssemblyName helpers to managed (#62866)

* Moved ComputePublicKeyToken to managed

* Managed assembly name parsing (adapted from nativeaot)

* Fix for HostActivation failures.

* PR feedback (RuntimeAssemblyName is back to CoreRT + other comments)

* remove AssemblyNameNative::Init form the .hpp

* remove AppX compat ifdef

* renamed instance fields to convention used in C#

* `Argument_InvalidAssemblyName`   should be   `InvalidAssemblyName`. Majority of use is `FileLoadException`.

* remove `this.`

* PR feedback (assign to fileds, bypass properties)

* missed this change in the rebase

* "low-hanging fruit" perf tweaks.

* move one-user helpers to where they are used.

* removed ActiveIssue for #45032

* remove AssemblyNameHelpers.cs form corelib

* Remove the List when detecting duplicates. Support PublicKey.

* whitespace

* Fix managed implementation to match the new tests.

* Some minor cleanup.

* Do not validate culture too early

* PR feedback

* use SR.InvalidAssemblyName

* Report the input string when throwing FileLoadException

* tweaked couple comments
---
 .../System/Reflection/AssemblyName.CoreCLR.cs |  18 -
 .../Runtime/Augments/RuntimeAugments.cs       |   5 +
 .../src/System.Private.CoreLib.csproj         |   6 +-
 .../System/Reflection/AssemblyName.CoreRT.cs  |  19 -
 .../System/Reflection/AssemblyNameHelpers.cs  |  47 +-
 .../System/Reflection/AssemblyNameLexer.cs    | 136 ------
 .../System/Reflection/AssemblyNameParser.cs   | 230 ----------
 .../Reflection/AssemblyRuntimeNameHelpers.cs  |  52 +++
 .../System/Reflection/RuntimeAssemblyName.cs  |  27 +-
 .../Core/Execution/ExecutionDomain.cs         |   2 +-
 .../Runtime/TypeParsing/TypeLexer.cs          |   4 +-
 src/coreclr/vm/assembly.cpp                   |   2 +-
 src/coreclr/vm/assemblyname.cpp               |  73 +--
 src/coreclr/vm/assemblyname.hpp               |   2 -
 src/coreclr/vm/assemblynative.cpp             |   5 +-
 src/coreclr/vm/assemblyspec.cpp               | 174 +++----
 src/coreclr/vm/assemblyspec.hpp               |   4 +-
 src/coreclr/vm/ecalllist.h                    |   2 -
 .../src/Resources/Strings.resx                |   7 +-
 .../System.Private.CoreLib.Shared.projitems   |   4 +-
 .../src/System/Reflection/AssemblyName.cs     |  30 +-
 .../AssemblyNameHelpers.StrongName.cs         |   3 +-
 .../System/Reflection/AssemblyNameParser.cs   | 427 ++++++++++++++++++
 .../src/System/ThrowHelper.cs                 |   6 +
 .../tests/AssemblyNameTests.cs                |   1 -
 .../System/Reflection/AssemblyName.Mono.cs    |  50 --
 src/mono/mono/metadata/icall-decl.h           |   1 -
 src/mono/mono/metadata/icall-def-netcore.h    |   2 -
 src/mono/mono/metadata/icall.c                |  15 -
 29 files changed, 628 insertions(+), 726 deletions(-)
 delete mode 100644 src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameLexer.cs
 delete mode 100644 src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs
 create mode 100644 src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyRuntimeNameHelpers.cs
 rename src/{coreclr/nativeaot => libraries}/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.StrongName.cs (98%)
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs
index f45b3837abdd93..0a3cd42ba900a5 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs
@@ -11,18 +11,6 @@ namespace System.Reflection
 {
     public sealed partial class AssemblyName : ICloneable, IDeserializationCallback, ISerializable
     {
-        public AssemblyName(string assemblyName)
-        {
-            if (assemblyName == null)
-                throw new ArgumentNullException(nameof(assemblyName));
-            if ((assemblyName.Length == 0) ||
-                (assemblyName[0] == '\0'))
-                throw new ArgumentException(SR.Format_StringZeroLength);
-
-            _name = assemblyName;
-            nInit();
-        }
-
         internal AssemblyName(string? name,
             byte[]? publicKey,
             byte[]? publicKeyToken,
@@ -44,9 +32,6 @@ internal AssemblyName(string? name,
             _flags = flags;
         }
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern void nInit();
-
         // This call opens and closes the file, but does not add the
         // assembly to the domain.
         [MethodImpl(MethodImplOptions.InternalCall)]
@@ -58,9 +43,6 @@ internal static AssemblyName GetFileInformationCore(string assemblyFile)
             return nGetFileInformation(fullPath);
         }
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private extern byte[]? ComputePublicKeyToken();
-
         internal void SetProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm)
         {
 #pragma warning disable SYSLIB0037 // AssemblyName.ProcessorArchitecture is obsolete
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs
index 2cc2f40a841f89..198172362464a0 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs
@@ -1091,5 +1091,10 @@ public static bool IsPrimitive(RuntimeTypeHandle typeHandle)
         {
             return typeHandle.ToEETypePtr().IsPrimitive && !typeHandle.ToEETypePtr().IsEnum;
         }
+
+        public static byte[] ComputePublicKeyToken(byte[] publicKey)
+        {
+            return System.Reflection.AssemblyNameHelpers.ComputePublicKeyToken(publicKey);
+        }
     }
 }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj b/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj
index cf0cab0700ebac..bc79d83f0d4768 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj
@@ -123,12 +123,10 @@
     <Compile Include="Internal\Reflection\Extensions\NonPortable\CustomAttributeSearcher.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="System\Reflection\AssemblyNameHelpers.StrongName.cs" />
-    <Compile Include="System\Reflection\AssemblyNameHelpers.cs" />
-    <Compile Include="System\Reflection\AssemblyNameLexer.cs" />
-    <Compile Include="System\Reflection\AssemblyNameParser.cs" />
     <Compile Include="System\Reflection\RuntimeAssembly.cs" />
     <Compile Include="System\Reflection\RuntimeAssemblyName.cs" />
+    <Compile Include="System\Reflection\AssemblyNameHelpers.cs" />
+    <Compile Include="System\Reflection\AssemblyRuntimeNameHelpers.cs" />
     <Compile Include="System\Reflection\Attribute.CoreRT.cs" />
     <Compile Include="System\Reflection\Assembly.CoreRT.cs" />
     <Compile Include="System\Reflection\AssemblyName.CoreRT.cs" />
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs
index bc3ef378043153..7efcf64288a621 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs
@@ -7,25 +7,6 @@ namespace System.Reflection
 {
     public sealed partial class AssemblyName : ICloneable, IDeserializationCallback, ISerializable
     {
-        public AssemblyName(string assemblyName)
-            : this()
-        {
-            if (assemblyName == null)
-                throw new ArgumentNullException(nameof(assemblyName));
-            if ((assemblyName.Length == 0) ||
-                (assemblyName[0] == '\0'))
-                throw new ArgumentException(SR.Format_StringZeroLength);
-
-            _name = assemblyName;
-            RuntimeAssemblyName runtimeAssemblyName = AssemblyNameParser.Parse(_name);
-            runtimeAssemblyName.CopyToAssemblyName(this);
-        }
-
-        private byte[] ComputePublicKeyToken()
-        {
-            return AssemblyNameHelpers.ComputePublicKeyToken(_publicKey);
-        }
-
         private static AssemblyName GetFileInformationCore(string assemblyFile)
         {
             throw new PlatformNotSupportedException(SR.PlatformNotSupported_AssemblyName_GetAssemblyName);
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.cs
index b259e2b6bfbdc3..a79f9f7f653071 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.cs
@@ -9,41 +9,8 @@
 
 namespace System.Reflection
 {
-    [System.Runtime.CompilerServices.ReflectionBlocked]
-    public static partial class AssemblyNameHelpers
+    internal static partial class AssemblyNameHelpers
     {
-        //
-        // Converts an AssemblyName to a RuntimeAssemblyName that is free from any future mutations on the AssemblyName.
-        //
-        public static RuntimeAssemblyName ToRuntimeAssemblyName(this AssemblyName assemblyName)
-        {
-            if (assemblyName.Name == null)
-                throw new ArgumentException();
-
-            AssemblyNameFlags flags = assemblyName.Flags;
-            AssemblyContentType contentType = assemblyName.ContentType;
-#pragma warning disable SYSLIB0037 // AssemblyName.ProcessorArchitecture is obsolete
-            ProcessorArchitecture processorArchitecture = assemblyName.ProcessorArchitecture;
-#pragma warning restore SYSLIB0037
-            AssemblyNameFlags combinedFlags = CombineAssemblyNameFlags(flags, contentType, processorArchitecture);
-            byte[]? pkOriginal;
-            if (0 != (flags & AssemblyNameFlags.PublicKey))
-                pkOriginal = assemblyName.GetPublicKey();
-            else
-                pkOriginal = assemblyName.GetPublicKeyToken();
-
-            // AssemblyName's PKT property getters do NOT copy the array before giving it out. Make our own copy
-            // as the original is wide open to tampering by anyone.
-            byte[]? pkCopy = null;
-            if (pkOriginal != null)
-            {
-                pkCopy = new byte[pkOriginal.Length];
-                ((ICollection<byte>)pkOriginal).CopyTo(pkCopy, 0);
-            }
-
-            return new RuntimeAssemblyName(assemblyName.Name, assemblyName.Version, assemblyName.CultureName, combinedFlags, pkCopy);
-        }
-
         //
         // These helpers convert between the combined flags+contentType+processorArchitecture value and the separated parts.
         //
@@ -55,19 +22,9 @@ internal static AssemblyContentType ExtractAssemblyContentType(this AssemblyName
             return (AssemblyContentType)((((int)flags) >> 9) & 0x7);
         }
 
-        internal static ProcessorArchitecture ExtractProcessorArchitecture(this AssemblyNameFlags flags)
-        {
-            return (ProcessorArchitecture)((((int)flags) >> 4) & 0x7);
-        }
-
-        public static AssemblyNameFlags ExtractAssemblyNameFlags(this AssemblyNameFlags combinedFlags)
+        internal static AssemblyNameFlags ExtractAssemblyNameFlags(this AssemblyNameFlags combinedFlags)
         {
             return combinedFlags & unchecked((AssemblyNameFlags)0xFFFFF10F);
         }
-
-        internal static AssemblyNameFlags CombineAssemblyNameFlags(AssemblyNameFlags flags, AssemblyContentType contentType, ProcessorArchitecture processorArchitecture)
-        {
-            return (AssemblyNameFlags)(((int)flags) | (((int)contentType) << 9) | ((int)processorArchitecture << 4));
-        }
     }
 }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameLexer.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameLexer.cs
deleted file mode 100644
index 84555ab310d454..00000000000000
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameLexer.cs
+++ /dev/null
@@ -1,136 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.IO;
-using System.Text;
-using System.Globalization;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace System.Reflection
-{
-    //
-    // A simple lexer for assembly display names.
-    //
-    internal struct AssemblyNameLexer
-    {
-        internal AssemblyNameLexer(string s)
-        {
-            // Convert string to char[] with NUL terminator. (An actual NUL terminator in the input string will be treated
-            // as an actual end of string: this is compatible with desktop behavior.)
-            char[] chars = new char[s.Length + 1];
-            s.CopyTo(0, chars, 0, s.Length);
-            _chars = chars;
-            _index = 0;
-        }
-
-        //
-        // Return the next token in assembly name. If you expect the result to be DisplayNameToken.String,
-        // use GetNext(out String) instead.
-        //
-        internal Token GetNext()
-        {
-            return GetNext(out _);
-        }
-
-        //
-        // Return the next token in assembly name. If the result is DisplayNameToken.String,
-        // sets "tokenString" to the tokenized string.
-        //
-        internal Token GetNext(out string tokenString)
-        {
-            tokenString = null;
-            while (char.IsWhiteSpace(_chars[_index]))
-                _index++;
-
-            char c = _chars[_index++];
-            if (c == 0)
-                return Token.End;
-            if (c == ',')
-                return Token.Comma;
-            if (c == '=')
-                return Token.Equals;
-
-            StringBuilder sb = new StringBuilder();
-
-            char quoteChar = (char)0;
-            if (c == '\'' || c == '\"')
-            {
-                quoteChar = c;
-                c = _chars[_index++];
-            }
-
-            for (;;)
-            {
-                if (c == 0)
-                {
-                    _index--;
-                    break;  // Terminate: End of string (desktop compat: if string was quoted, permitted to terminate without end-quote.)
-                }
-
-                if (quoteChar != 0 && c == quoteChar)
-                    break;  // Terminate: Found closing quote of quoted string.
-
-                if (quoteChar == 0 && (c == ',' || c == '='))
-                {
-                    _index--;
-                    break;  // Terminate: Found start of a new ',' or '=' token.
-                }
-
-                if (quoteChar == 0 && (c == '\'' || c == '\"'))
-                    throw new FileLoadException();  // Desktop compat: Unescaped quote illegal unless entire string is quoted.
-
-                if (c == '\\')
-                {
-                    c = _chars[_index++];
-
-                    switch (c)
-                    {
-                        case '\\':
-                        case ',':
-                        case '=':
-                        case '\'':
-                        case '"':
-                            sb.Append(c);
-                            break;
-                        case 't':
-                            sb.Append('\t');
-                            break;
-                        case 'r':
-                            sb.Append('\r');
-                            break;
-                        case 'n':
-                            sb.Append('\n');
-                            break;
-                        default:
-                            throw new FileLoadException();  // Unrecognized escape
-                    }
-                }
-                else
-                {
-                    sb.Append(c);
-                }
-
-                c = _chars[_index++];
-            }
-
-            tokenString = sb.ToString();
-            if (quoteChar == 0)
-                tokenString = tokenString.Trim(); // Unless quoted, whitespace at beginning or end doesn't count.
-            return Token.String;
-        }
-
-        // Token categories for display name lexer.
-        internal enum Token
-        {
-            Equals = 1,
-            Comma = 2,
-            String = 3,
-            End = 4,
-        }
-
-        private readonly char[] _chars;
-        private int _index;
-    }
-}
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs
deleted file mode 100644
index 5d8f2ef1c34b0a..00000000000000
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs
+++ /dev/null
@@ -1,230 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.IO;
-using System.Text;
-using System.Diagnostics;
-using System.Globalization;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace System.Reflection
-{
-    //
-    // Parses an assembly name.
-    //
-    [System.Runtime.CompilerServices.ReflectionBlocked]
-    public static class AssemblyNameParser
-    {
-        public static void Parse(AssemblyName blank, string s)
-        {
-            if (s == null)
-                throw new ArgumentNullException(nameof(s));
-            RuntimeAssemblyName runtimeAssemblyName = Parse(s);
-            runtimeAssemblyName.CopyToAssemblyName(blank);
-        }
-
-        public static RuntimeAssemblyName Parse(string s)
-        {
-            Debug.Assert(s != null);
-
-            int indexOfNul = s.IndexOf((char)0);
-            if (indexOfNul != -1)
-                s = s.Substring(0, indexOfNul);
-            if (s.Length == 0)
-                throw new ArgumentException(SR.Format_StringZeroLength);
-
-            AssemblyNameLexer lexer = new AssemblyNameLexer(s);
-
-            // Name must come first.
-            string name;
-            AssemblyNameLexer.Token token = lexer.GetNext(out name);
-            if (token != AssemblyNameLexer.Token.String)
-                throw new FileLoadException(SR.InvalidAssemblyName);
-
-            if (name == string.Empty || name.IndexOfAny(s_illegalCharactersInSimpleName) != -1)
-                throw new FileLoadException(SR.InvalidAssemblyName);
-
-            Version? version = null;
-            string? cultureName = null;
-            byte[]? pkt = null;
-            AssemblyNameFlags flags = 0;
-
-            LowLevelList<string> alreadySeen = new LowLevelList<string>();
-            token = lexer.GetNext();
-            while (token != AssemblyNameLexer.Token.End)
-            {
-                if (token != AssemblyNameLexer.Token.Comma)
-                    throw new FileLoadException(SR.InvalidAssemblyName);
-                string attributeName;
-
-                token = lexer.GetNext(out attributeName);
-                if (token != AssemblyNameLexer.Token.String)
-                    throw new FileLoadException(SR.InvalidAssemblyName);
-                token = lexer.GetNext();
-
-                // Compat note: Inside AppX apps, the desktop CLR's AssemblyName parser skips past any elements that don't follow the "<Something>=<Something>" pattern.
-                //  (when running classic Windows apps, such an illegal construction throws an exception as expected.)
-                // Naturally, at least one app unwittingly takes advantage of this.
-                if (token == AssemblyNameLexer.Token.Comma || token == AssemblyNameLexer.Token.End)
-                    continue;
-
-                if (token != AssemblyNameLexer.Token.Equals)
-                    throw new FileLoadException(SR.InvalidAssemblyName);
-                string attributeValue;
-                token = lexer.GetNext(out attributeValue);
-                if (token != AssemblyNameLexer.Token.String)
-                    throw new FileLoadException(SR.InvalidAssemblyName);
-
-                if (attributeName == string.Empty)
-                    throw new FileLoadException(SR.InvalidAssemblyName);
-
-                for (int i = 0; i < alreadySeen.Count; i++)
-                {
-                    if (alreadySeen[i].Equals(attributeName, StringComparison.OrdinalIgnoreCase))
-                        throw new FileLoadException(SR.InvalidAssemblyName); // Cannot specify the same attribute twice.
-                }
-                alreadySeen.Add(attributeName);
-
-                if (attributeName.Equals("Version", StringComparison.OrdinalIgnoreCase))
-                {
-                    version = ParseVersion(attributeValue);
-                }
-
-                if (attributeName.Equals("Culture", StringComparison.OrdinalIgnoreCase))
-                {
-                    cultureName = ParseCulture(attributeValue);
-                }
-
-                if (attributeName.Equals("PublicKeyToken", StringComparison.OrdinalIgnoreCase))
-                {
-                    pkt = ParsePKT(attributeValue);
-                }
-
-                if (attributeName.Equals("ProcessorArchitecture", StringComparison.OrdinalIgnoreCase))
-                {
-                    flags |= (AssemblyNameFlags)(((int)ParseProcessorArchitecture(attributeValue)) << 4);
-                }
-
-                if (attributeName.Equals("Retargetable", StringComparison.OrdinalIgnoreCase))
-                {
-                    if (attributeValue.Equals("Yes", StringComparison.OrdinalIgnoreCase))
-                        flags |= AssemblyNameFlags.Retargetable;
-                    else if (attributeValue.Equals("No", StringComparison.OrdinalIgnoreCase))
-                    {
-                        // nothing to do
-                    }
-                    else
-                        throw new FileLoadException(SR.InvalidAssemblyName);
-                }
-
-                if (attributeName.Equals("ContentType", StringComparison.OrdinalIgnoreCase))
-                {
-                    if (attributeValue.Equals("WindowsRuntime", StringComparison.OrdinalIgnoreCase))
-                        flags |= (AssemblyNameFlags)(((int)AssemblyContentType.WindowsRuntime) << 9);
-                    else
-                        throw new FileLoadException(SR.InvalidAssemblyName);
-                }
-
-                // Desktop compat: If we got here, the attribute name is unknown to us. Ignore it (as long it's not duplicated.)
-                token = lexer.GetNext();
-            }
-            return new RuntimeAssemblyName(name, version, cultureName, flags, pkt);
-        }
-
-        private static Version ParseVersion(string attributeValue)
-        {
-            string[] parts = attributeValue.Split('.');
-            if (parts.Length > 4)
-                throw new FileLoadException(SR.InvalidAssemblyName);
-            ushort[] versionNumbers = new ushort[4];
-            for (int i = 0; i < versionNumbers.Length; i++)
-            {
-                if (i >= parts.Length)
-                    versionNumbers[i] = ushort.MaxValue;
-                else
-                {
-                    // Desktop compat: TryParse is a little more forgiving than Fusion.
-                    for (int j = 0; j < parts[i].Length; j++)
-                    {
-                        if (!char.IsDigit(parts[i][j]))
-                            throw new FileLoadException(SR.InvalidAssemblyName);
-                    }
-                    if (!(ushort.TryParse(parts[i], out versionNumbers[i])))
-                    {
-                        throw new FileLoadException(SR.InvalidAssemblyName);
-                    }
-                }
-            }
-
-            if (versionNumbers[0] == ushort.MaxValue || versionNumbers[1] == ushort.MaxValue)
-                throw new FileLoadException(SR.InvalidAssemblyName);
-            if (versionNumbers[2] == ushort.MaxValue)
-                return new Version(versionNumbers[0], versionNumbers[1]);
-            if (versionNumbers[3] == ushort.MaxValue)
-                return new Version(versionNumbers[0], versionNumbers[1], versionNumbers[2]);
-            return new Version(versionNumbers[0], versionNumbers[1], versionNumbers[2], versionNumbers[3]);
-        }
-
-        private static string ParseCulture(string attributeValue)
-        {
-            if (attributeValue.Equals("Neutral", StringComparison.OrdinalIgnoreCase))
-            {
-                return "";
-            }
-            else
-            {
-                CultureInfo culture = CultureInfo.GetCultureInfo(attributeValue); // Force a CultureNotFoundException if not a valid culture.
-                return culture.Name;
-            }
-        }
-
-        private static byte[] ParsePKT(string attributeValue)
-        {
-            if (attributeValue.Equals("null", StringComparison.OrdinalIgnoreCase) || attributeValue == string.Empty)
-                return Array.Empty<byte>();
-
-            if (attributeValue.Length != 8 * 2)
-                throw new FileLoadException(SR.InvalidAssemblyName);
-
-            byte[] pkt = new byte[8];
-            int srcIndex = 0;
-            for (int i = 0; i < 8; i++)
-            {
-                char hi = attributeValue[srcIndex++];
-                char lo = attributeValue[srcIndex++];
-                pkt[i] = (byte)((ParseHexNybble(hi) << 4) | ParseHexNybble(lo));
-            }
-            return pkt;
-        }
-
-        private static ProcessorArchitecture ParseProcessorArchitecture(string attributeValue)
-        {
-            if (attributeValue.Equals("msil", StringComparison.OrdinalIgnoreCase))
-                return ProcessorArchitecture.MSIL;
-            if (attributeValue.Equals("x86", StringComparison.OrdinalIgnoreCase))
-                return ProcessorArchitecture.X86;
-            if (attributeValue.Equals("ia64", StringComparison.OrdinalIgnoreCase))
-                return ProcessorArchitecture.IA64;
-            if (attributeValue.Equals("amd64", StringComparison.OrdinalIgnoreCase))
-                return ProcessorArchitecture.Amd64;
-            if (attributeValue.Equals("arm", StringComparison.OrdinalIgnoreCase))
-                return ProcessorArchitecture.Arm;
-            throw new FileLoadException(SR.InvalidAssemblyName);
-        }
-
-        private static byte ParseHexNybble(char c)
-        {
-            if (c >= '0' && c <= '9')
-                return (byte)(c - '0');
-            if (c >= 'a' && c <= 'f')
-                return (byte)(c - 'a' + 10);
-            if (c >= 'A' && c <= 'F')
-                return (byte)(c - 'A' + 10);
-            throw new FileLoadException(SR.InvalidAssemblyName);
-        }
-
-        private static readonly char[] s_illegalCharactersInSimpleName = { '/', '\\', ':' };
-    }
-}
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyRuntimeNameHelpers.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyRuntimeNameHelpers.cs
new file mode 100644
index 00000000000000..fc4ed2816e5802
--- /dev/null
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyRuntimeNameHelpers.cs
@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+
+namespace System.Reflection
+{
+    [System.Runtime.CompilerServices.ReflectionBlocked]
+    public static class AssemblyRuntimeNameHelpers
+    {
+        //
+        // Converts an AssemblyName to a RuntimeAssemblyName that is free from any future mutations on the AssemblyName.
+        //
+        public static RuntimeAssemblyName ToRuntimeAssemblyName(this AssemblyName assemblyName)
+        {
+            if (assemblyName.Name == null)
+                throw new ArgumentException(SR.InvalidAssemblyName);
+
+            AssemblyNameFlags flags = assemblyName.Flags;
+            AssemblyContentType contentType = assemblyName.ContentType;
+#pragma warning disable SYSLIB0037 // AssemblyName.ProcessorArchitecture is obsolete
+            ProcessorArchitecture processorArchitecture = assemblyName.ProcessorArchitecture;
+#pragma warning restore SYSLIB0037
+            AssemblyNameFlags combinedFlags = CombineAssemblyNameFlags(flags, contentType, processorArchitecture);
+            byte[]? pkOriginal;
+            if (0 != (flags & AssemblyNameFlags.PublicKey))
+                pkOriginal = assemblyName.GetPublicKey();
+            else
+                pkOriginal = assemblyName.GetPublicKeyToken();
+
+            // AssemblyName's PKT property getters do NOT copy the array before giving it out. Make our own copy
+            // as the original is wide open to tampering by anyone.
+            byte[]? pkCopy = null;
+            if (pkOriginal != null)
+            {
+                pkCopy = new byte[pkOriginal.Length];
+                Array.Copy(pkOriginal, pkCopy, pkOriginal.Length);
+            }
+
+            return new RuntimeAssemblyName(assemblyName.Name, assemblyName.Version, assemblyName.CultureName, combinedFlags, pkCopy);
+        }
+
+        internal static AssemblyNameFlags CombineAssemblyNameFlags(AssemblyNameFlags flags, AssemblyContentType contentType, ProcessorArchitecture processorArchitecture)
+        {
+            return (AssemblyNameFlags)(((int)flags) | (((int)contentType) << 9) | ((int)processorArchitecture << 4));
+        }
+    }
+}
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/RuntimeAssemblyName.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/RuntimeAssemblyName.cs
index 90c0fe5ff824a8..f4dbc0d667140d 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/RuntimeAssemblyName.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/RuntimeAssemblyName.cs
@@ -16,7 +16,7 @@ namespace System.Reflection
     //
     public sealed class RuntimeAssemblyName : IEquatable<RuntimeAssemblyName>
     {
-        public RuntimeAssemblyName(string name, Version version, string cultureName, AssemblyNameFlags flags, byte[] publicKeyOrToken)
+        public RuntimeAssemblyName(string name, Version? version, string? cultureName, AssemblyNameFlags flags, byte[]? publicKeyOrToken)
         {
             Debug.Assert(name != null);
             this.Name = name;
@@ -34,20 +34,26 @@ public RuntimeAssemblyName(string name, Version version, string cultureName, Ass
             this.PublicKeyOrToken = publicKeyOrToken;
         }
 
+        public static RuntimeAssemblyName Parse(string name)
+        {
+            AssemblyNameParser.AssemblyNameParts parts = AssemblyNameParser.Parse(name);
+            return new RuntimeAssemblyName(parts._name, parts._version, parts._cultureName, parts._flags, parts._publicKeyOrToken);
+        }
+
         // Simple name.
         public string Name { get; }
 
         // Optional version.
-        public Version Version { get; }
+        public Version? Version { get; }
 
         // Optional culture name.
-        public string CultureName { get; }
+        public string? CultureName { get; }
 
         // Optional flags (this is actually an OR of the classic flags and the ContentType.)
         public AssemblyNameFlags Flags { get; }
 
         // Optional public key (if Flags.PublicKey == true) or public key token.
-        public byte[] PublicKeyOrToken { get; }
+        public byte[]? PublicKeyOrToken { get; }
 
         // Equality - this compares every bit of data in the RuntimeAssemblyName which is acceptable for use as keys in a cache
         // where semantic duplication is permissible. This method is *not* meant to define ref->def binding rules or
@@ -73,8 +79,8 @@ public bool Equals(RuntimeAssemblyName? other)
             if (this.Flags != other.Flags)
                 return false;
 
-            byte[] thisPK = this.PublicKeyOrToken;
-            byte[] otherPK = other.PublicKeyOrToken;
+            byte[]? thisPK = this.PublicKeyOrToken;
+            byte[]? otherPK = other.PublicKeyOrToken;
             if (thisPK == null)
             {
                 if (otherPK != null)
@@ -139,7 +145,7 @@ public void CopyToAssemblyName(AssemblyName blank)
             blank.Flags = this.Flags.ExtractAssemblyNameFlags();
             blank.ContentType = this.Flags.ExtractAssemblyContentType();
 #pragma warning disable SYSLIB0037 // AssemblyName.ProcessorArchitecture is obsolete
-            blank.ProcessorArchitecture = this.Flags.ExtractProcessorArchitecture();
+            blank.ProcessorArchitecture = ExtractProcessorArchitecture(this.Flags);
 #pragma warning restore SYSLIB0037
 
             if (this.PublicKeyOrToken != null)
@@ -162,9 +168,14 @@ public string FullName
         {
             get
             {
-                byte[] pkt = (0 != (Flags & AssemblyNameFlags.PublicKey)) ? AssemblyNameHelpers.ComputePublicKeyToken(PublicKeyOrToken) : PublicKeyOrToken;
+                byte[]? pkt = (0 != (Flags & AssemblyNameFlags.PublicKey)) ? AssemblyNameHelpers.ComputePublicKeyToken(PublicKeyOrToken) : PublicKeyOrToken;
                 return AssemblyNameFormatter.ComputeDisplayName(Name, Version, CultureName, pkt, Flags.ExtractAssemblyNameFlags(), Flags.ExtractAssemblyContentType());
             }
         }
+
+        internal static ProcessorArchitecture ExtractProcessorArchitecture(AssemblyNameFlags flags)
+        {
+            return (ProcessorArchitecture)((((int)flags) >> 4) & 0x7);
+        }
     }
 }
diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/Internal/Reflection/Core/Execution/ExecutionDomain.cs b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/Internal/Reflection/Core/Execution/ExecutionDomain.cs
index 53edc6a6ec5e49..2227d4a59682b4 100644
--- a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/Internal/Reflection/Core/Execution/ExecutionDomain.cs
+++ b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/Internal/Reflection/Core/Execution/ExecutionDomain.cs
@@ -89,7 +89,7 @@ private static CoreTypeResolver CreateCoreTypeResolver(Func<Assembly, string, bo
                     {
                         foreach (string defaultAssemblyName in defaultAssemblyNames)
                         {
-                            RuntimeAssemblyName runtimeAssemblyName = AssemblyNameParser.Parse(defaultAssemblyName);
+                            RuntimeAssemblyName runtimeAssemblyName = RuntimeAssemblyName.Parse(defaultAssemblyName);
                             RuntimeAssemblyInfo defaultAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(runtimeAssemblyName);
                             if (defaultAssembly == null)
                                 continue;
diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeParsing/TypeLexer.cs b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeParsing/TypeLexer.cs
index dfebfcacea21d1..2dc289a7c2fa42 100644
--- a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeParsing/TypeLexer.cs
+++ b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/TypeParsing/TypeLexer.cs
@@ -139,7 +139,7 @@ public RuntimeAssemblyName GetNextAssemblyName()
             }
             _index = src;
             string fullName = new string(buffer, 0, dst);
-            return AssemblyNameParser.Parse(fullName);
+            return RuntimeAssemblyName.Parse(fullName);
         }
 
         //
@@ -173,7 +173,7 @@ public RuntimeAssemblyName GetNextEmbeddedAssemblyName()
             }
             _index = src;
             string fullName = new string(buffer, 0, dst);
-            return AssemblyNameParser.Parse(fullName);
+            return RuntimeAssemblyName.Parse(fullName);
         }
 
         //
diff --git a/src/coreclr/vm/assembly.cpp b/src/coreclr/vm/assembly.cpp
index 09c6ff22c2f838..9176b757b88582 100644
--- a/src/coreclr/vm/assembly.cpp
+++ b/src/coreclr/vm/assembly.cpp
@@ -429,7 +429,7 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, C
         || name.Find(i, ':')
         || name.Find(i, '/'))
     {
-        COMPlusThrow(kArgumentException, W("Argument_InvalidAssemblyName"));
+        COMPlusThrow(kArgumentException, W("InvalidAssemblyName"));
     }
 
     // Set up the assembly manifest metadata
diff --git a/src/coreclr/vm/assemblyname.cpp b/src/coreclr/vm/assemblyname.cpp
index bd6e41e52611b3..8cf625cad095d7 100644
--- a/src/coreclr/vm/assemblyname.cpp
+++ b/src/coreclr/vm/assemblyname.cpp
@@ -60,81 +60,10 @@ FCIMPL1(Object*, AssemblyNameNative::GetFileInformation, StringObject* filenameU
     pImage->VerifyIsAssembly();
 
     AssemblySpec spec;
-    spec.InitializeSpec(TokenFromRid(mdtAssembly,1),pImage->GetMDImport(),NULL);
+    spec.InitializeSpec(TokenFromRid(1,mdtAssembly),pImage->GetMDImport(),NULL);
     spec.AssemblyNameInit(&gc.result, pImage);
 
     HELPER_METHOD_FRAME_END();
     return OBJECTREFToObject(gc.result);
 }
 FCIMPLEND
-
-FCIMPL1(Object*, AssemblyNameNative::GetPublicKeyToken, Object* refThisUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    U1ARRAYREF orOutputArray = NULL;
-    OBJECTREF refThis       = (OBJECTREF) refThisUNSAFE;
-    HELPER_METHOD_FRAME_BEGIN_RET_1(refThis);
-
-    if (refThis == NULL)
-        COMPlusThrow(kNullReferenceException, W("NullReference_This"));
-
-    ASSEMBLYNAMEREF orThis = (ASSEMBLYNAMEREF)refThis;
-    U1ARRAYREF orPublicKey = orThis->GetPublicKey();
-
-    if (orPublicKey != NULL) {
-        DWORD cb = orPublicKey->GetNumComponents();
-        StrongNameBufferHolder<BYTE> pbToken;
-
-        if (cb) {
-            CQuickBytes qb;
-            BYTE *pbKey = (BYTE*) qb.AllocThrows(cb);
-            memcpy(pbKey, orPublicKey->GetDataPtr(), cb);
-
-            {
-                GCX_PREEMP();
-                IfFailThrow(StrongNameTokenFromPublicKey(pbKey, cb, &pbToken, &cb));
-            }
-        }
-
-        orOutputArray = (U1ARRAYREF)AllocatePrimitiveArray(ELEMENT_TYPE_U1, cb);
-        memcpyNoGCRefs(orOutputArray->m_Array, pbToken, cb);
-    }
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(orOutputArray);
-}
-FCIMPLEND
-
-
-FCIMPL1(void, AssemblyNameNative::Init, Object * refThisUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    ASSEMBLYNAMEREF pThis = (ASSEMBLYNAMEREF) (OBJECTREF) refThisUNSAFE;
-    HRESULT hr = S_OK;
-
-    HELPER_METHOD_FRAME_BEGIN_1(pThis);
-
-    if (pThis == NULL)
-        COMPlusThrow(kNullReferenceException, W("NullReference_This"));
-
-    ACQUIRE_STACKING_ALLOCATOR(pStackingAllocator);
-
-    AssemblySpec spec;
-    hr = spec.InitializeSpec(pStackingAllocator, (ASSEMBLYNAMEREF *) &pThis, TRUE);
-
-    if (SUCCEEDED(hr))
-    {
-        spec.AssemblyNameInit(&pThis,NULL);
-    }
-    else
-    {
-        ThrowHR(hr);
-    }
-
-    HELPER_METHOD_FRAME_END();
-}
-FCIMPLEND
-
-
diff --git a/src/coreclr/vm/assemblyname.hpp b/src/coreclr/vm/assemblyname.hpp
index 9e818fc1a9f7cc..a336cfaf9ae701 100644
--- a/src/coreclr/vm/assemblyname.hpp
+++ b/src/coreclr/vm/assemblyname.hpp
@@ -19,8 +19,6 @@ class AssemblyNameNative
 {
 public:
     static FCDECL1(Object*, GetFileInformation, StringObject* filenameUNSAFE);
-    static FCDECL1(Object*, GetPublicKeyToken, Object* refThisUNSAFE);
-    static FCDECL1(void, Init, Object * refThisUNSAFE);
 };
 
 #endif  // _AssemblyName_H
diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp
index a51280e21e4a34..19a5d62c0b9ed0 100644
--- a/src/coreclr/vm/assemblynative.cpp
+++ b/src/coreclr/vm/assemblynative.cpp
@@ -86,9 +86,8 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(QCall::ObjectHandleOnStack
     }
 
     // Initialize spec
-    spec.InitializeSpec(pStackingAllocator,
-                        &assemblyNameRef,
-                        FALSE);
+    spec.InitializeSpec(pStackingAllocator, &assemblyNameRef);
+
     GCPROTECT_END();
 
     spec.SetCodeBase(NULL);
diff --git a/src/coreclr/vm/assemblyspec.cpp b/src/coreclr/vm/assemblyspec.cpp
index 0cea7dc7121070..5bdb2cbd65259e 100644
--- a/src/coreclr/vm/assemblyspec.cpp
+++ b/src/coreclr/vm/assemblyspec.cpp
@@ -250,8 +250,7 @@ void AssemblySpec::InitializeSpec(PEAssembly * pFile)
 
 
 // This uses thread storage to allocate space. Please use Checkpoint and release it.
-HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF* pName,
-                                  BOOL fParse /*=TRUE*/)
+void AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF* pName)
 {
     CONTRACTL
     {
@@ -271,11 +270,6 @@ HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF*
         WCHAR* pString;
         int    iString;
         ((STRINGREF) (*pName)->GetSimpleName())->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
-
-        // we will not parse names that contain nulls
-        if (fParse && (wcslen(pString) != (size_t)iString))
-            ThrowHR(FUSION_E_INVALID_NAME);
-
         DWORD lgth = WszWideCharToMultiByte(CP_UTF8, 0, pString, iString, NULL, 0, NULL, NULL);
         if (lgth + 1 < lgth)
             ThrowHR(E_INVALIDARG);
@@ -295,108 +289,86 @@ HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF*
         SetName(lpName);
     }
 
-    if (fParse)
-    {
-        HRESULT hr = ParseName();
-        // Sometimes Fusion flags invalid characters in the name, sometimes it doesn't
-        // depending on where the invalid characters are
-        // We want to Raise the assembly resolve event on all invalid characters
-        // but calling ParseName before checking for invalid characters gives Fusion a chance to
-        // parse the rest of the name (to get a public key token, etc.)
-        if ((hr == FUSION_E_INVALID_NAME) || (!IsValidAssemblyName())) {
-            // This is the only case where we do not throw on an error
-            // We don't want to throw so as to give the caller a chance to call RaiseAssemblyResolveEvent
-            // The only caller that cares is System.Reflection.Assembly.InternalLoad which calls us through
-            // AssemblyNameNative::Init
-            return FUSION_E_INVALID_NAME;
-        }
-        else
-            IfFailThrow(hr);
+    AssemblyMetaDataInternal asmInfo;
+    // Flags
+    DWORD dwFlags = (*pName)->GetFlags();
+
+    // Version
+    VERSIONREF version = (VERSIONREF) (*pName)->GetVersion();
+    if(version == NULL) {
+        asmInfo.usMajorVersion = (USHORT)-1;
+        asmInfo.usMinorVersion = (USHORT)-1;
+        asmInfo.usBuildNumber = (USHORT)-1;
+        asmInfo.usRevisionNumber = (USHORT)-1;
     }
     else {
-        AssemblyMetaDataInternal asmInfo;
-        // Flags
-        DWORD dwFlags = (*pName)->GetFlags();
-
-        // Version
-        VERSIONREF version = (VERSIONREF) (*pName)->GetVersion();
-        if(version == NULL) {
-            asmInfo.usMajorVersion = (USHORT)-1;
-            asmInfo.usMinorVersion = (USHORT)-1;
-            asmInfo.usBuildNumber = (USHORT)-1;
-            asmInfo.usRevisionNumber = (USHORT)-1;
-        }
-        else {
-            asmInfo.usMajorVersion = (USHORT)version->GetMajor();
-            asmInfo.usMinorVersion = (USHORT)version->GetMinor();
-            asmInfo.usBuildNumber = (USHORT)version->GetBuild();
-            asmInfo.usRevisionNumber = (USHORT)version->GetRevision();
-        }
+        asmInfo.usMajorVersion = (USHORT)version->GetMajor();
+        asmInfo.usMinorVersion = (USHORT)version->GetMinor();
+        asmInfo.usBuildNumber = (USHORT)version->GetBuild();
+        asmInfo.usRevisionNumber = (USHORT)version->GetRevision();
+    }
 
-        asmInfo.szLocale = 0;
+    asmInfo.szLocale = 0;
 
-        if ((*pName)->GetCultureInfo() != NULL)
-        {
-            struct _gc {
-                OBJECTREF   cultureinfo;
-                STRINGREF   pString;
-            } gc;
-
-            gc.cultureinfo = (*pName)->GetCultureInfo();
-            gc.pString = NULL;
-
-            GCPROTECT_BEGIN(gc);
-
-            MethodDescCallSite getName(METHOD__CULTURE_INFO__GET_NAME, &gc.cultureinfo);
-
-            ARG_SLOT args[] = {
-                ObjToArgSlot(gc.cultureinfo)
-            };
-            gc.pString = getName.Call_RetSTRINGREF(args);
-            if (gc.pString != NULL) {
-                WCHAR* pString;
-                int    iString;
-                gc.pString->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
-                DWORD lgth = WszWideCharToMultiByte(CP_UTF8, 0, pString, iString, NULL, 0, NULL, NULL);
-                S_UINT32 lengthWillNull = S_UINT32(lgth) + S_UINT32(1);
-                LPSTR lpLocale = (LPSTR) alloc->Alloc(lengthWillNull);
-                if (lengthWillNull.IsOverflow())
-                {
-                    COMPlusThrowHR(COR_E_OVERFLOW);
-                }
-                WszWideCharToMultiByte(CP_UTF8, 0, pString, iString,
-                                       lpLocale, lengthWillNull.Value(), NULL, NULL);
-                lpLocale[lgth] = '\0';
-                asmInfo.szLocale = lpLocale;
-            }
-            GCPROTECT_END();
-        }
+    if ((*pName)->GetCultureInfo() != NULL)
+    {
+        struct _gc {
+            OBJECTREF   cultureinfo;
+            STRINGREF   pString;
+        } gc;
 
-        // Strong name
-        DWORD cbPublicKeyOrToken=0;
-        BYTE* pbPublicKeyOrToken=NULL;
-        // Note that we prefer to take a public key token if present,
-        // even if flags indicate a full public key
-        if ((*pName)->GetPublicKeyToken() != NULL) {
-            dwFlags &= ~afPublicKey;
-            PBYTE  pArray = NULL;
-            pArray = (*pName)->GetPublicKeyToken()->GetDirectPointerToNonObjectElements();
-            cbPublicKeyOrToken = (*pName)->GetPublicKeyToken()->GetNumComponents();
-            pbPublicKeyOrToken = pArray;
-        }
-        else if ((*pName)->GetPublicKey() != NULL) {
-            dwFlags |= afPublicKey;
-            PBYTE  pArray = NULL;
-            pArray = (*pName)->GetPublicKey()->GetDirectPointerToNonObjectElements();
-            cbPublicKeyOrToken = (*pName)->GetPublicKey()->GetNumComponents();
-            pbPublicKeyOrToken = pArray;
+        gc.cultureinfo = (*pName)->GetCultureInfo();
+        gc.pString = NULL;
+
+        GCPROTECT_BEGIN(gc);
+
+        MethodDescCallSite getName(METHOD__CULTURE_INFO__GET_NAME, &gc.cultureinfo);
+
+        ARG_SLOT args[] = {
+            ObjToArgSlot(gc.cultureinfo)
+        };
+        gc.pString = getName.Call_RetSTRINGREF(args);
+        if (gc.pString != NULL) {
+            WCHAR* pString;
+            int    iString;
+            gc.pString->RefInterpretGetStringValuesDangerousForGC(&pString, &iString);
+            DWORD lgth = WszWideCharToMultiByte(CP_UTF8, 0, pString, iString, NULL, 0, NULL, NULL);
+            S_UINT32 lengthWillNull = S_UINT32(lgth) + S_UINT32(1);
+            LPSTR lpLocale = (LPSTR) alloc->Alloc(lengthWillNull);
+            if (lengthWillNull.IsOverflow())
+            {
+                COMPlusThrowHR(COR_E_OVERFLOW);
+            }
+            WszWideCharToMultiByte(CP_UTF8, 0, pString, iString,
+                                   lpLocale, lengthWillNull.Value(), NULL, NULL);
+            lpLocale[lgth] = '\0';
+            asmInfo.szLocale = lpLocale;
         }
-        BaseAssemblySpec::Init(GetName(),&asmInfo,pbPublicKeyOrToken,cbPublicKeyOrToken,dwFlags);
-    }
+        GCPROTECT_END();
+    }
+
+    // Strong name
+    DWORD cbPublicKeyOrToken=0;
+    BYTE* pbPublicKeyOrToken=NULL;
+    // Note that we prefer to take a public key token if present,
+    // even if flags indicate a full public key
+    if ((*pName)->GetPublicKeyToken() != NULL) {
+        dwFlags &= ~afPublicKey;
+        PBYTE  pArray = NULL;
+        pArray = (*pName)->GetPublicKeyToken()->GetDirectPointerToNonObjectElements();
+        cbPublicKeyOrToken = (*pName)->GetPublicKeyToken()->GetNumComponents();
+        pbPublicKeyOrToken = pArray;
+    }
+    else if ((*pName)->GetPublicKey() != NULL) {
+        dwFlags |= afPublicKey;
+        PBYTE  pArray = NULL;
+        pArray = (*pName)->GetPublicKey()->GetDirectPointerToNonObjectElements();
+        cbPublicKeyOrToken = (*pName)->GetPublicKey()->GetNumComponents();
+        pbPublicKeyOrToken = pArray;
+    }
+    BaseAssemblySpec::Init(GetName(),&asmInfo,pbPublicKeyOrToken,cbPublicKeyOrToken,dwFlags);
 
     CloneFieldsToStackingAllocator(alloc);
-
-    return S_OK;
 }
 
 void AssemblySpec::AssemblyNameInit(ASSEMBLYNAMEREF* pAsmName, PEImage* pImageInfo)
diff --git a/src/coreclr/vm/assemblyspec.hpp b/src/coreclr/vm/assemblyspec.hpp
index d6ce12300170ed..9f49c1d78cf751 100644
--- a/src/coreclr/vm/assemblyspec.hpp
+++ b/src/coreclr/vm/assemblyspec.hpp
@@ -103,9 +103,7 @@ class AssemblySpec  : public BaseAssemblySpec
 
 
     void InitializeSpec(PEAssembly* pPEAssembly);
-    HRESULT InitializeSpec(StackingAllocator* alloc,
-                        ASSEMBLYNAMEREF* pName,
-                        BOOL fParse);
+    void InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF* pName);
 
     void AssemblyNameInit(ASSEMBLYNAMEREF* pName, PEImage* pImageInfo); //[in,out], [in]
 
diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
index f3ada145b68395..8a11c4fb930ab8 100644
--- a/src/coreclr/vm/ecalllist.h
+++ b/src/coreclr/vm/ecalllist.h
@@ -292,8 +292,6 @@ FCFuncStart(gAssemblyLoadContextFuncs)
 FCFuncEnd()
 
 FCFuncStart(gAssemblyNameFuncs)
-    FCFuncElement("nInit", AssemblyNameNative::Init)
-    FCFuncElement("ComputePublicKeyToken", AssemblyNameNative::GetPublicKeyToken)
     FCFuncElement("nGetFileInformation", AssemblyNameNative::GetFileInformation)
 FCFuncEnd()
 
diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
index e9d5e447ee90fc..8564b3894fa410 100644
--- a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -1104,8 +1104,8 @@
   <data name="Argument_InvalidArrayType" xml:space="preserve">
     <value>Target array type is not compatible with the type of items in the collection.</value>
   </data>
-  <data name="Argument_InvalidAssemblyName" xml:space="preserve">
-    <value>Assembly names may not begin with whitespace or contain the characters '/', or '\\' or ':'.</value>
+  <data name="InvalidAssemblyName" xml:space="preserve">
+    <value>The given assembly name or codebase was invalid.</value>
   </data>
   <data name="Argument_InvalidCalendar" xml:space="preserve">
     <value>Not a valid calendar for the given culture.</value>
@@ -3877,9 +3877,6 @@
   <data name="TypeInitialization_Type_NoTypeAvailable" xml:space="preserve">
     <value>A type initializer threw an exception. To determine which type, inspect the InnerException's StackTrace property.</value>
   </data>
-  <data name="InvalidAssemblyName" xml:space="preserve">
-    <value>The given assembly name or codebase was invalid</value>
-  </data>
   <data name="Security_InvalidAssemblyPublicKey" xml:space="preserve">
     <value>Invalid assembly public key.</value>
   </data>
diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index d5ce32af96642c..8cf5cf0dda601b 100644
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -562,6 +562,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyKeyNameAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyMetadataAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyName.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyNameHelpers.StrongName.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyNameParser.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyNameFlags.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyNameFormatter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\AssemblyNameProxy.cs" />
@@ -2369,4 +2371,4 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryNegationOperators.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryPlusOperators.cs" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs
index 198c6804b7e4f2..a1822fbe83a1ac 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs
@@ -25,6 +25,32 @@ public sealed partial class AssemblyName : ICloneable, IDeserializationCallback,
         private AssemblyVersionCompatibility _versionCompatibility;
         private AssemblyNameFlags _flags;
 
+        public AssemblyName(string assemblyName)
+            : this()
+        {
+            if (assemblyName == null)
+                throw new ArgumentNullException(nameof(assemblyName));
+            if ((assemblyName.Length == 0) ||
+                (assemblyName[0] == '\0'))
+                throw new ArgumentException(SR.Format_StringZeroLength);
+
+            AssemblyNameParser.AssemblyNameParts parts = AssemblyNameParser.Parse(assemblyName);
+            _name = parts._name;
+            _version = parts._version;
+            _flags = parts._flags;
+            if ((parts._flags & AssemblyNameFlags.PublicKey) != 0)
+            {
+                _publicKey = parts._publicKeyOrToken;
+            }
+            else
+            {
+                _publicKeyToken = parts._publicKeyOrToken;
+            }
+
+            if (parts._cultureName != null)
+                _cultureInfo = new CultureInfo(parts._cultureName);
+        }
+
         public AssemblyName()
         {
             _versionCompatibility = AssemblyVersionCompatibility.SameMachine;
@@ -166,7 +192,7 @@ public void SetPublicKey(byte[]? publicKey)
 
         // The compressed version of the public key formed from a truncated hash.
         // Will throw a SecurityException if _publicKey is invalid
-        public byte[]? GetPublicKeyToken() => _publicKeyToken ??= ComputePublicKeyToken();
+        public byte[]? GetPublicKeyToken() => _publicKeyToken ??= AssemblyNameHelpers.ComputePublicKeyToken(_publicKey);
 
         public void SetPublicKeyToken(byte[]? publicKeyToken)
         {
@@ -219,7 +245,7 @@ public string FullName
                     return string.Empty;
 
                 // Do not call GetPublicKeyToken() here - that latches the result into AssemblyName which isn't a side effect we want.
-                byte[]? pkt = _publicKeyToken ?? ComputePublicKeyToken();
+                byte[]? pkt = _publicKeyToken ?? AssemblyNameHelpers.ComputePublicKeyToken(_publicKey);
                 return AssemblyNameFormatter.ComputeDisplayName(Name, Version, CultureName, pkt, Flags, ContentType);
             }
         }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.StrongName.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.StrongName.cs
similarity index 98%
rename from src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.StrongName.cs
rename to src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.StrongName.cs
index 85e437548102e3..ef05ef39f8a7e9 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.StrongName.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyNameHelpers.StrongName.cs
@@ -2,12 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers.Binary;
-using System.Runtime;
 using System.Security;
 
 namespace System.Reflection
 {
-    public static partial class AssemblyNameHelpers
+    internal static partial class AssemblyNameHelpers
     {
         public static byte[]? ComputePublicKeyToken(byte[]? publicKey)
         {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs
new file mode 100644
index 00000000000000..ab3be2c8f06d20
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyNameParser.cs
@@ -0,0 +1,427 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace System.Reflection
+{
+    //
+    // Parses an assembly name.
+    //
+    internal ref struct AssemblyNameParser
+    {
+        public struct AssemblyNameParts
+        {
+            public AssemblyNameParts(string name, Version? version, string? cultureName, AssemblyNameFlags flags, byte[]? publicKeyOrToken)
+            {
+                _name = name;
+                _version = version;
+                _cultureName = cultureName;
+                _flags = flags;
+                _publicKeyOrToken = publicKeyOrToken;
+            }
+
+            public string _name;
+            public Version? _version;
+            public string? _cultureName;
+            public AssemblyNameFlags _flags;
+            public byte[]? _publicKeyOrToken;
+        }
+
+        // Token categories for the lexer.
+        private enum Token
+        {
+            Equals = 1,
+            Comma = 2,
+            String = 3,
+            End = 4,
+        }
+
+        private enum AttributeKind
+        {
+            Version = 1,
+            Culture = 2,
+            PublicKeyOrToken = 4,
+            ProcessorArchitecture = 8,
+            Retargetable = 16,
+            ContentType = 32
+        }
+
+        private static readonly char[] s_illegalCharactersInSimpleName = { '/', '\\', ':' };
+        private string _input;
+        private int _index;
+
+        private AssemblyNameParser(string input)
+        {
+            Debug.Assert(input != null);
+            if (input.Length == 0)
+                throw new ArgumentException(SR.Format_StringZeroLength);
+
+            _input = input;
+            _index = 0;
+        }
+
+        public static AssemblyNameParts Parse(string s)
+        {
+            return new AssemblyNameParser(s).Parse();
+        }
+
+        private void RecordNewSeenOrThrow(ref AttributeKind seenAttributes, AttributeKind newAttribute)
+        {
+            if ((seenAttributes & newAttribute) != 0)
+            {
+                ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+            }
+            else
+            {
+                seenAttributes |= newAttribute;
+            }
+        }
+
+        private AssemblyNameParts Parse()
+        {
+            // Name must come first.
+            string name;
+            Token token = GetNextToken(out name);
+            if (token != Token.String)
+                ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+
+            if (name == string.Empty || name.IndexOfAny(s_illegalCharactersInSimpleName) != -1)
+                ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+
+            Version? version = null;
+            string? cultureName = null;
+            byte[]? pkt = null;
+            AssemblyNameFlags flags = 0;
+
+            AttributeKind alreadySeen = default;
+            token = GetNextToken();
+            while (token != Token.End)
+            {
+                if (token != Token.Comma)
+                    ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                string attributeName;
+
+                token = GetNextToken(out attributeName);
+                if (token != Token.String)
+                    ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                token = GetNextToken();
+
+                if (token != Token.Equals)
+                    ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                string attributeValue;
+                token = GetNextToken(out attributeValue);
+                if (token != Token.String)
+                    ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+
+                if (attributeName == string.Empty)
+                    ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+
+                if (attributeName.Equals("Version", StringComparison.OrdinalIgnoreCase))
+                {
+                    RecordNewSeenOrThrow(ref alreadySeen, AttributeKind.Version);
+                    version = ParseVersion(attributeValue);
+                }
+
+                if (attributeName.Equals("Culture", StringComparison.OrdinalIgnoreCase))
+                {
+                    RecordNewSeenOrThrow(ref alreadySeen, AttributeKind.Culture);
+                    cultureName = ParseCulture(attributeValue);
+                }
+
+                if (attributeName.Equals("PublicKey", StringComparison.OrdinalIgnoreCase))
+                {
+                    RecordNewSeenOrThrow(ref alreadySeen, AttributeKind.PublicKeyOrToken);
+                    pkt = ParsePKT(attributeValue, isToken: false);
+                    flags |= AssemblyNameFlags.PublicKey;
+                }
+
+                if (attributeName.Equals("PublicKeyToken", StringComparison.OrdinalIgnoreCase))
+                {
+                    RecordNewSeenOrThrow(ref alreadySeen, AttributeKind.PublicKeyOrToken);
+                    pkt = ParsePKT(attributeValue, isToken: true);
+                }
+
+                if (attributeName.Equals("ProcessorArchitecture", StringComparison.OrdinalIgnoreCase))
+                {
+                    RecordNewSeenOrThrow(ref alreadySeen, AttributeKind.ProcessorArchitecture);
+                    flags |= (AssemblyNameFlags)(((int)ParseProcessorArchitecture(attributeValue)) << 4);
+                }
+
+                if (attributeName.Equals("Retargetable", StringComparison.OrdinalIgnoreCase))
+                {
+                    RecordNewSeenOrThrow(ref alreadySeen, AttributeKind.Retargetable);
+                    if (attributeValue.Equals("Yes", StringComparison.OrdinalIgnoreCase))
+                        flags |= AssemblyNameFlags.Retargetable;
+                    else if (attributeValue.Equals("No", StringComparison.OrdinalIgnoreCase))
+                    {
+                        // nothing to do
+                    }
+                    else
+                        ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                }
+
+                if (attributeName.Equals("ContentType", StringComparison.OrdinalIgnoreCase))
+                {
+                    RecordNewSeenOrThrow(ref alreadySeen, AttributeKind.ContentType);
+                    if (attributeValue.Equals("WindowsRuntime", StringComparison.OrdinalIgnoreCase))
+                        flags |= (AssemblyNameFlags)(((int)AssemblyContentType.WindowsRuntime) << 9);
+                    else
+                        ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                }
+
+                // Desktop compat: If we got here, the attribute name is unknown to us. Ignore it.
+                token = GetNextToken();
+            }
+
+            return new AssemblyNameParts(name, version, cultureName, flags, pkt);
+        }
+
+        private Version ParseVersion(string attributeValue)
+        {
+            string[] parts = attributeValue.Split('.');
+            if (parts.Length > 4)
+                ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+            ushort[] versionNumbers = new ushort[4];
+            for (int i = 0; i < versionNumbers.Length; i++)
+            {
+                if (i >= parts.Length)
+                    versionNumbers[i] = ushort.MaxValue;
+                else
+                {
+                    // Desktop compat: TryParse is a little more forgiving than Fusion.
+                    for (int j = 0; j < parts[i].Length; j++)
+                    {
+                        if (!char.IsDigit(parts[i][j]))
+                            ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                    }
+                    if (!(ushort.TryParse(parts[i], out versionNumbers[i])))
+                    {
+                        ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                    }
+                }
+            }
+
+            if (versionNumbers[0] == ushort.MaxValue || versionNumbers[1] == ushort.MaxValue)
+                ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+            if (versionNumbers[2] == ushort.MaxValue)
+                return new Version(versionNumbers[0], versionNumbers[1]);
+            if (versionNumbers[3] == ushort.MaxValue)
+                return new Version(versionNumbers[0], versionNumbers[1], versionNumbers[2]);
+            return new Version(versionNumbers[0], versionNumbers[1], versionNumbers[2], versionNumbers[3]);
+        }
+
+        private string ParseCulture(string attributeValue)
+        {
+            if (attributeValue.Equals("Neutral", StringComparison.OrdinalIgnoreCase))
+            {
+                return "";
+            }
+
+            return attributeValue;
+        }
+
+        private byte[] ParsePKT(string attributeValue, bool isToken)
+        {
+            if (attributeValue.Equals("null", StringComparison.OrdinalIgnoreCase) || attributeValue == string.Empty)
+                return Array.Empty<byte>();
+
+            if (isToken && attributeValue.Length != 8 * 2)
+                ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+
+            byte[] pkt = new byte[attributeValue.Length / 2];
+            int srcIndex = 0;
+            for (int i = 0; i < pkt.Length; i++)
+            {
+                char hi = attributeValue[srcIndex++];
+                char lo = attributeValue[srcIndex++];
+                pkt[i] = (byte)((ParseHexNybble(hi) << 4) | ParseHexNybble(lo));
+            }
+            return pkt;
+        }
+
+        private ProcessorArchitecture ParseProcessorArchitecture(string attributeValue)
+        {
+            if (attributeValue.Equals("msil", StringComparison.OrdinalIgnoreCase))
+                return ProcessorArchitecture.MSIL;
+            if (attributeValue.Equals("x86", StringComparison.OrdinalIgnoreCase))
+                return ProcessorArchitecture.X86;
+            if (attributeValue.Equals("ia64", StringComparison.OrdinalIgnoreCase))
+                return ProcessorArchitecture.IA64;
+            if (attributeValue.Equals("amd64", StringComparison.OrdinalIgnoreCase))
+                return ProcessorArchitecture.Amd64;
+            if (attributeValue.Equals("arm", StringComparison.OrdinalIgnoreCase))
+                return ProcessorArchitecture.Arm;
+            ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+            return default; // unreachable
+        }
+
+        private byte ParseHexNybble(char c)
+        {
+            if (c >= '0' && c <= '9')
+                return (byte)(c - '0');
+            if (c >= 'a' && c <= 'f')
+                return (byte)(c - 'a' + 10);
+            if (c >= 'A' && c <= 'F')
+                return (byte)(c - 'A' + 10);
+            ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+            return default; // unreachable
+        }
+
+        //
+        // Return the next token in assembly name. If you expect the result to be Token.String,
+        // use GetNext(out String) instead.
+        //
+        private Token GetNextToken()
+        {
+            return GetNextToken(out _);
+        }
+
+        private static bool IsWhiteSpace(char ch)
+        {
+            switch (ch)
+            {
+                case '\n':
+                case '\r':
+                case ' ':
+                case '\t':
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private char GetNextChar()
+        {
+            char ch;
+            if (_index < _input.Length)
+            {
+                ch = _input[_index++];
+                if (ch == '\0')
+                {
+                    ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                }
+            }
+            else
+            {
+                ch = '\0';
+            }
+
+            return ch;
+        }
+
+        //
+        // Return the next token in assembly name. If the result is Token.String,
+        // sets "tokenString" to the tokenized string.
+        //
+        private Token GetNextToken(out string tokenString)
+        {
+            tokenString = string.Empty;
+            char c;
+
+            while (true)
+            {
+                c = GetNextChar();
+                switch (c)
+                {
+                    case ',':
+                        return Token.Comma;
+                    case '=':
+                        return Token.Equals;
+                    case '\0':
+                        return Token.End;
+                }
+
+                if (!IsWhiteSpace(c))
+                {
+                    break;
+                }
+            }
+
+            ValueStringBuilder sb = new ValueStringBuilder(stackalloc char[64]);
+
+            char quoteChar = '\0';
+            if (c == '\'' || c == '\"')
+            {
+                quoteChar = c;
+                c = GetNextChar();
+            }
+
+            for (; ; )
+            {
+                if (c == 0)
+                {
+                    if (quoteChar != 0)
+                    {
+                        // EOS and unclosed quotes is an error
+                        ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                    }
+                    else
+                    {
+                        // Reached end of input and therefore of string
+                        break;
+                    }
+                }
+
+                if (quoteChar != 0 && c == quoteChar)
+                    break;  // Terminate: Found closing quote of quoted string.
+
+                if (quoteChar == 0 && (c == ',' || c == '='))
+                {
+                    _index--;
+                    break;  // Terminate: Found start of a new ',' or '=' token.
+                }
+
+                if (quoteChar == 0 && (c == '\'' || c == '\"'))
+                    ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+
+                if (c == '\\')
+                {
+                    c = GetNextChar();
+
+                    switch (c)
+                    {
+                        case '\\':
+                        case ',':
+                        case '=':
+                        case '\'':
+                        case '"':
+                            sb.Append(c);
+                            break;
+                        case 't':
+                            sb.Append('\t');
+                            break;
+                        case 'r':
+                            sb.Append('\r');
+                            break;
+                        case 'n':
+                            sb.Append('\n');
+                            break;
+                        default:
+                            ThrowHelper.ThrowFileLoadException_InvalidAssemblyName(_input);
+                            return default; //unreachable
+                    }
+                }
+                else
+                {
+                    sb.Append(c);
+                }
+
+                c = GetNextChar();
+            }
+
+
+            if (quoteChar == 0)
+            {
+                while (sb.Length > 0 && IsWhiteSpace(sb[sb.Length - 1]))
+                    sb.Length--;
+            }
+
+            tokenString = sb.ToString();
+            return Token.String;
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs
index 01e4a44dfc19d0..781cd38aaadb30 100644
--- a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs
@@ -494,6 +494,12 @@ internal static void ThrowFormatException_BadFormatSpecifier()
             throw new FormatException(SR.Argument_BadFormatSpecifier);
         }
 
+        [DoesNotReturn]
+        internal static void ThrowFileLoadException_InvalidAssemblyName(string name)
+        {
+            throw new FileLoadException(SR.InvalidAssemblyName, name);
+        }
+
         [DoesNotReturn]
         internal static void ThrowArgumentOutOfRangeException_PrecisionTooLarge()
         {
diff --git a/src/libraries/System.Reflection/tests/AssemblyNameTests.cs b/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
index 7e9b8c5849b22d..34a7023e2e6078 100644
--- a/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
+++ b/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
@@ -124,7 +124,6 @@ public void Ctor_String_Invalid_Legacy(string assemblyName, Type exceptionType)
         [InlineData("na=me", typeof(FileLoadException))]
         [InlineData("na\'me", typeof(FileLoadException))]
         [InlineData("na\"me", typeof(FileLoadException))]
-        [ActiveIssue ("https://github.com/dotnet/runtime/issues/45032", TestRuntimes.Mono)]
         public void Ctor_String_Invalid_Issue(string assemblyName, Type exceptionType)
         {
             Assert.Throws(exceptionType, () => new AssemblyName(assemblyName));
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
index 12b2a5936c3ded..67ff341eec5df9 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
@@ -12,50 +12,6 @@ namespace System.Reflection
 {
     public partial class AssemblyName
     {
-        public AssemblyName(string assemblyName)
-        {
-            if (assemblyName == null)
-                throw new ArgumentNullException(nameof(assemblyName));
-            if (assemblyName.Length == 0 || assemblyName[0] == '\0')
-                throw new ArgumentException(SR.Format_StringZeroLength);
-
-            if (assemblyName.Contains('\0'))
-                throw new FileLoadException("The assembly name is invalid.");
-
-            using (SafeStringMarshal name = RuntimeMarshal.MarshalString(assemblyName))
-            {
-                // TODO: Should use CoreRT AssemblyNameParser
-                if (!ParseAssemblyName(name.Value, out MonoAssemblyName nativeName, out bool isVersionDefined, out bool isTokenDefined))
-                    throw new FileLoadException("The assembly name is invalid.");
-
-                try
-                {
-                    unsafe
-                    {
-                        FillName(&nativeName, null, isVersionDefined, false, isTokenDefined);
-                    }
-                }
-                finally
-                {
-                    RuntimeMarshal.FreeAssemblyName(ref nativeName, false);
-                }
-            }
-        }
-
-        private unsafe byte[]? ComputePublicKeyToken()
-        {
-            if (_publicKey == null)
-                return null;
-            if (_publicKey.Length == 0)
-                return Array.Empty<byte>();
-
-            var token = new byte[8];
-            fixed (byte* pkt = token)
-            fixed (byte* pk = _publicKey)
-                get_public_token(pkt, pk, _publicKey.Length);
-            return token;
-        }
-
         internal static AssemblyName Create(IntPtr monoAssembly, string? codeBase)
         {
             AssemblyName aname = new AssemblyName();
@@ -141,13 +97,7 @@ private static AssemblyName GetFileInformationCore(string assemblyFile)
             }
         }
 
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        private static extern unsafe void get_public_token(byte* token, byte* pubkey, int len);
-
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern unsafe MonoAssemblyName* GetNativeName(IntPtr assemblyPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool ParseAssemblyName(IntPtr name, out MonoAssemblyName aname, out bool is_version_definited, out bool is_token_defined);
     }
 }
diff --git a/src/mono/mono/metadata/icall-decl.h b/src/mono/mono/metadata/icall-decl.h
index 5b75710e6456ad..1a960fdaa86555 100644
--- a/src/mono/mono/metadata/icall-decl.h
+++ b/src/mono/mono/metadata/icall-decl.h
@@ -60,7 +60,6 @@ typedef enum {
 // This is sorted.
 // grep ICALL_EXPORT | sort | uniq
 ICALL_EXPORT MonoAssemblyName* ves_icall_System_Reflection_AssemblyName_GetNativeName (MonoAssembly*);
-ICALL_EXPORT MonoBoolean ves_icall_System_Reflection_AssemblyName_ParseAssemblyName (const char*, MonoAssemblyName*, MonoBoolean*, MonoBoolean* is_token_defined_arg);
 ICALL_EXPORT MonoBoolean ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack (void);
 ICALL_EXPORT MonoBoolean ves_icall_System_Threading_Thread_YieldInternal (void);
 ICALL_EXPORT MonoThread *ves_icall_System_Threading_Thread_GetCurrentThread (void);
diff --git a/src/mono/mono/metadata/icall-def-netcore.h b/src/mono/mono/metadata/icall-def-netcore.h
index 45c65207a08497..ae7984fada9b04 100644
--- a/src/mono/mono/metadata/icall-def-netcore.h
+++ b/src/mono/mono/metadata/icall-def-netcore.h
@@ -176,8 +176,6 @@ HANDLES(ASSEM_7, "InternalLoad", ves_icall_System_Reflection_Assembly_InternalLo
 
 ICALL_TYPE(ASSEMN, "System.Reflection.AssemblyName", ASSEMN_0)
 NOHANDLES(ICALL(ASSEMN_0, "GetNativeName", ves_icall_System_Reflection_AssemblyName_GetNativeName))
-NOHANDLES(ICALL(ASSEMN_3, "ParseAssemblyName", ves_icall_System_Reflection_AssemblyName_ParseAssemblyName))
-NOHANDLES(ICALL(ASSEMN_2, "get_public_token", mono_digest_get_public_token))
 
 ICALL_TYPE(MCATTR, "System.Reflection.CustomAttribute", MCATTR_1)
 HANDLES(MCATTR_1, "GetCustomAttributesDataInternal", ves_icall_MonoCustomAttrs_GetCustomAttributesDataInternal, MonoArray, 1, (MonoObject))
diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c
index 39806dd249178b..92e0526e1c2b4c 100644
--- a/src/mono/mono/metadata/icall.c
+++ b/src/mono/mono/metadata/icall.c
@@ -5379,21 +5379,6 @@ gint32 ves_icall_AssemblyExtensions_ApplyUpdateEnabled (gint32 just_component_ch
 	return mono_metadata_update_available () && (just_component_check || mono_metadata_update_enabled (NULL));
 }
 
-MonoBoolean
-ves_icall_System_Reflection_AssemblyName_ParseAssemblyName (const char *name, MonoAssemblyName *aname, MonoBoolean *is_version_defined_arg, MonoBoolean *is_token_defined_arg)
-{
-	gboolean is_version_defined = FALSE;
-	gboolean is_token_defined = FALSE;
-	gboolean result = FALSE;
-
-	result = mono_assembly_name_parse_full (name, aname, TRUE, &is_version_defined, &is_token_defined);
-
-	*is_version_defined_arg = (MonoBoolean)is_version_defined;
-	*is_token_defined_arg = (MonoBoolean)is_token_defined;
-
-	return result;
-}
-
 MonoReflectionTypeHandle
 ves_icall_System_Reflection_RuntimeModule_GetGlobalType (MonoImage *image, MonoError *error)
 {

From ca1340bb034fca163375a6da88f22b1843d633ef Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 25 Jan 2022 18:01:02 -0500
Subject: [PATCH 070/161] Disable RegexReductionTests tests on browser

---
 .../System.Text.RegularExpressions/tests/RegexReductionTests.cs  | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
index 65ef818124a425..f4fcbf92dadf1c 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
@@ -6,6 +6,7 @@
 
 namespace System.Text.RegularExpressions.Tests
 {
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/64300", TestPlatforms.Browser)]
     public class RegexReductionTests
     {
         // These tests depend on using reflection to access internals of Regex in order to validate

From bdc0d1a409a24d4092e7b108c13fc4ff1c643d1f Mon Sep 17 00:00:00 2001
From: Roman Marusyk <Marusyk@users.noreply.github.com>
Date: Wed, 26 Jan 2022 01:08:51 +0200
Subject: [PATCH 071/161] Fix formatting of resource string where excess
 arguments are passed (#63824)

* Fix formatting of resource string where excess arguments are passed. #63607

* Fix BuildCharExceptionArgs and ECCurve.Validate

* Fix CA2208

* Fix CA2208. Remove paramName becaus it is in error message

* Code review fixes

* Code review fixes
---
 .../Microsoft/VisualBasic/FileIO/TextFieldParser.vb  |  8 ++++----
 .../src/Microsoft/Win32/Registry.cs                  |  2 +-
 .../AccessControl/RegistrySecurity.Windows.cs        |  2 +-
 .../src/System/Drawing/RectangleConverter.cs         |  2 +-
 .../BasicEventSourceTest/TestsManifestNegative.cs    | 12 ++++++------
 .../src/System/Drawing/RectangleConverter.cs         |  1 -
 .../src/System/IO/IsolatedStorage/IsolatedStorage.cs |  2 +-
 .../System.IO.Packaging/src/Resources/Strings.resx   |  4 ++--
 .../System.Net.NameResolution/src/System/Net/Dns.cs  |  6 +++---
 .../src/System/Net/Sockets/SocketAsyncEventArgs.cs   |  8 ++++----
 .../src/System/Collections/Hashtable.cs              |  2 +-
 .../src/System/Diagnostics/Tracing/EventSource.cs    |  6 +++---
 .../src/System/IO/UnmanagedMemoryAccessor.cs         |  4 ++--
 .../System.Private.CoreLib/src/System/Random.cs      |  2 +-
 .../src/System/Text/DecoderReplacementFallback.cs    |  2 +-
 .../src/System/Text/EncoderReplacementFallback.cs    |  2 +-
 .../tests/Xslt/XslTransformApi/CXslTransform.cs      |  2 +-
 .../System/Reflection/Metadata/Internal/BlobHeap.cs  |  2 +-
 .../src/System/Numerics/BigNumber.cs                 |  2 +-
 .../src/Resources/Strings.resx                       |  2 +-
 .../Cryptography/CspKeyContainerInfo.Windows.cs      |  4 ++--
 .../Cryptography/X509Certificates/X509Chain.cs       |  4 ++--
 .../src/Resources/Strings.resx                       |  2 +-
 .../src/System/Security/Cryptography/ECCurve.cs      |  4 ++--
 .../Fallback/DecoderReplacementFallbackTests.cs      | 12 ++++++------
 .../Fallback/EncoderReplacementFallbackTests.cs      | 12 ++++++------
 26 files changed, 55 insertions(+), 56 deletions(-)

diff --git a/src/libraries/Microsoft.VisualBasic.Core/src/Microsoft/VisualBasic/FileIO/TextFieldParser.vb b/src/libraries/Microsoft.VisualBasic.Core/src/Microsoft/VisualBasic/FileIO/TextFieldParser.vb
index 77219110807c4b..d97358dcd5a5b3 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/src/Microsoft/VisualBasic/FileIO/TextFieldParser.vb
+++ b/src/libraries/Microsoft.VisualBasic.Core/src/Microsoft/VisualBasic/FileIO/TextFieldParser.vb
@@ -375,7 +375,7 @@ Namespace Microsoft.VisualBasic.FileIO
         Public Function PeekChars(ByVal numberOfChars As Integer) As String
 
             If numberOfChars <= 0 Then
-                Throw GetArgumentExceptionWithArgName("numberOfChars", SR.TextFieldParser_NumberOfCharsMustBePositive, "numberOfChars")
+                Throw GetArgumentExceptionWithArgName("numberOfChars", SR.TextFieldParser_NumberOfCharsMustBePositive)
             End If
 
             If m_Reader Is Nothing Or m_Buffer Is Nothing Then
@@ -1151,7 +1151,7 @@ Namespace Microsoft.VisualBasic.FileIO
             Dim Bound As Integer = Widths.Length - 1
             For i As Integer = 0 To Bound - 1
                 If Widths(i) < 1 Then
-                    Throw GetArgumentExceptionWithArgName("FieldWidths", SR.TextFieldParser_FieldWidthsMustPositive, "FieldWidths")
+                    Throw GetArgumentExceptionWithArgName("FieldWidths", SR.TextFieldParser_FieldWidthsMustPositive)
                 End If
             Next
         End Sub
@@ -1163,11 +1163,11 @@ Namespace Microsoft.VisualBasic.FileIO
         ''' <remarks></remarks>
         Private Sub ValidateAndEscapeDelimiters()
             If m_Delimiters Is Nothing Then
-                Throw GetArgumentExceptionWithArgName("Delimiters", SR.TextFieldParser_DelimitersNothing, "Delimiters")
+                Throw GetArgumentExceptionWithArgName("Delimiters", SR.TextFieldParser_DelimitersNothing)
             End If
 
             If m_Delimiters.Length = 0 Then
-                Throw GetArgumentExceptionWithArgName("Delimiters", SR.TextFieldParser_DelimitersNothing, "Delimiters")
+                Throw GetArgumentExceptionWithArgName("Delimiters", SR.TextFieldParser_DelimitersNothing)
             End If
 
             Dim Length As Integer = m_Delimiters.Length
diff --git a/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/Registry.cs b/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/Registry.cs
index 56cbc26afe977c..49eeecff31ab0c 100644
--- a/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/Registry.cs
+++ b/src/libraries/Microsoft.Win32.Registry/src/Microsoft/Win32/Registry.cs
@@ -64,7 +64,7 @@ private static RegistryKey GetBaseKeyFromKeyName(string keyName, out string subK
                 return baseKey;
             }
 
-            throw new ArgumentException(SR.Format(SR.Arg_RegInvalidKeyName, nameof(keyName)), nameof(keyName));
+            throw new ArgumentException(SR.Arg_RegInvalidKeyName, nameof(keyName));
         }
 
         public static object? GetValue(string keyName, string? valueName, object? defaultValue)
diff --git a/src/libraries/Microsoft.Win32.Registry/src/System/Security/AccessControl/RegistrySecurity.Windows.cs b/src/libraries/Microsoft.Win32.Registry/src/System/Security/AccessControl/RegistrySecurity.Windows.cs
index f5ff293848ffa7..f16e03965ed186 100644
--- a/src/libraries/Microsoft.Win32.Registry/src/System/Security/AccessControl/RegistrySecurity.Windows.cs
+++ b/src/libraries/Microsoft.Win32.Registry/src/System/Security/AccessControl/RegistrySecurity.Windows.cs
@@ -19,7 +19,7 @@ public sealed partial class RegistrySecurity : NativeObjectSecurity
                     break;
 
                 case Interop.Errors.ERROR_INVALID_NAME:
-                    exception = new ArgumentException(SR.Format(SR.Arg_RegInvalidKeyName, nameof(name)));
+                    exception = new ArgumentException(SR.Arg_RegInvalidKeyName, nameof(name));
                     break;
 
                 case Interop.Errors.ERROR_INVALID_HANDLE:
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/Drawing/RectangleConverter.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/Drawing/RectangleConverter.cs
index 9037db51752749..9c0393da53ab33 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/System/Drawing/RectangleConverter.cs
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/Drawing/RectangleConverter.cs
@@ -50,7 +50,7 @@ public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destina
 
                 if (values.Length != 4)
                 {
-                    throw new ArgumentException(SR.Format(SR.TextParseFailedFormat, "text", text, "x, y, width, height"));
+                    throw new ArgumentException(SR.Format(SR.TextParseFailedFormat, text, "x, y, width, height"));
                 }
 
                 return new Rectangle(values[0], values[1], values[2], values[3]);
diff --git a/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestsManifestNegative.cs b/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestsManifestNegative.cs
index 2ee59adf59464f..012a03bcad1c16 100644
--- a/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestsManifestNegative.cs
+++ b/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestsManifestNegative.cs
@@ -82,13 +82,13 @@ public void Test_GenerateManifest_InvalidEventSources()
             Assert.NotNull(EventSource.GenerateManifest(typeof(Sdt.EventWithReturnEventSource), string.Empty, EventManifestOptions.AllowEventSourceOverride));
 
             e = AssertExtensions.Throws<ArgumentException>(null, () => EventSource.GenerateManifest(typeof(Sdt.NegativeEventIdEventSource), string.Empty));
-            AsserExceptionStringsEqual(() => GetResourceString("EventSource_NeedPositiveId", "WriteInteger"), e);
+            AsserExceptionStringsEqual(() => GetResourceString("EventSource_NeedPositiveId"), e);
 
             e = AssertExtensions.Throws<ArgumentException>(null, () => EventSource.GenerateManifest(typeof(Sdt.NegativeEventIdEventSource), string.Empty, strictOptions));
-            AsserExceptionStringsEqual(() => GetResourceString("EventSource_NeedPositiveId", "WriteInteger"), e);
+            AsserExceptionStringsEqual(() => GetResourceString("EventSource_NeedPositiveId"), e);
 
             e = AssertExtensions.Throws<ArgumentException>(null, () => EventSource.GenerateManifest(typeof(Sdt.NegativeEventIdEventSource), string.Empty, EventManifestOptions.AllowEventSourceOverride));
-            AsserExceptionStringsEqual(() => GetResourceString("EventSource_NeedPositiveId", "WriteInteger"), e);
+            AsserExceptionStringsEqual(() => GetResourceString("EventSource_NeedPositiveId"), e);
 
             e = AssertExtensions.Throws<ArgumentException>(null, () => EventSource.GenerateManifest(typeof(Sdt.OutOfRangeKwdEventSource), string.Empty, strictOptions));
             AsserExceptionStringsEqual(() => string.Join(Environment.NewLine,
@@ -124,7 +124,7 @@ public void Test_GenerateManifest_InvalidEventSources()
 
             e = AssertExtensions.Throws<ArgumentException>(null, () => EventSource.GenerateManifest(typeof(Sdt.EnumKindMismatchEventSource), string.Empty, strictOptions));
             AsserExceptionStringsEqual(() => string.Join(Environment.NewLine,
-                                     GetResourceString("EventSource_EnumKindMismatch", "Op1", "EventKeywords", "Opcodes"),
+                                     GetResourceString("EventSource_EnumKindMismatch", "EventKeywords", "Opcodes"),
                                      GetResourceString("EventSource_UndefinedKeyword", "0x1", "WriteInteger")),
                           e);
 
@@ -144,14 +144,14 @@ public void Test_GenerateManifest_InvalidEventSources()
 
             e = AssertExtensions.Throws<ArgumentException>(null, () => EventSource.GenerateManifest(typeof(Sdt.EventIdReusedEventSource), string.Empty, strictOptions));
             AsserExceptionStringsEqual(() => string.Join(Environment.NewLine,
-                                     GetResourceString("EventSource_EventIdReused", "WriteInteger2", 1, "WriteInteger1"),
+                                     GetResourceString("EventSource_EventIdReused", "WriteInteger2", 1),
                                      GetResourceString("EventSource_TaskOpcodePairReused", "WriteInteger2", 1, "WriteInteger1", 1)),
                           e);
 
 
             e = AssertExtensions.Throws<ArgumentException>(null, () => EventSource.GenerateManifest(typeof(Sdt.EventIdReusedEventSource), string.Empty, strictOptions));
             AsserExceptionStringsEqual(() => string.Join(Environment.NewLine,
-                                     GetResourceString("EventSource_EventIdReused", "WriteInteger2", 1, "WriteInteger1"),
+                                     GetResourceString("EventSource_EventIdReused", "WriteInteger2", 1),
                                      GetResourceString("EventSource_TaskOpcodePairReused", "WriteInteger2", 1, "WriteInteger1", 1)),
                           e);
 
diff --git a/src/libraries/System.Drawing.Common/src/System/Drawing/RectangleConverter.cs b/src/libraries/System.Drawing.Common/src/System/Drawing/RectangleConverter.cs
index 445d7c72c6dd49..098830cbf4a613 100644
--- a/src/libraries/System.Drawing.Common/src/System/Drawing/RectangleConverter.cs
+++ b/src/libraries/System.Drawing.Common/src/System/Drawing/RectangleConverter.cs
@@ -83,7 +83,6 @@ public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo c
                     }
                     else {
                         throw new ArgumentException(SR.Format(SR.TextParseFailedFormat,
-                                                                  "text",
                                                                   text,
                                                                   "x, y, width, height"));
                     }
diff --git a/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorage.cs b/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorage.cs
index 6171cce6d9a344..78dab308838122 100644
--- a/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorage.cs
+++ b/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorage.cs
@@ -55,7 +55,7 @@ public virtual ulong CurrentSize
         {
             get
             {
-                throw new InvalidOperationException(SR.Format(SR.IsolatedStorage_CurrentSizeUndefined, nameof(CurrentSize)));
+                throw new InvalidOperationException(SR.IsolatedStorage_CurrentSizeUndefined);
             }
         }
 
diff --git a/src/libraries/System.IO.Packaging/src/Resources/Strings.resx b/src/libraries/System.IO.Packaging/src/Resources/Strings.resx
index 668094559fa96f..a2ffa3af1ed3d7 100644
--- a/src/libraries/System.IO.Packaging/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Packaging/src/Resources/Strings.resx
@@ -106,7 +106,7 @@
     <value>Invalid file format.</value>
   </data>
   <data name="FileFormatExceptionWithFileName" xml:space="preserve">
-    <value>Invalid file format.</value>
+    <value>File '{0}' has an invalid file format.</value>
   </data>
   <data name="GetContentTypeCoreNotImplemented" xml:space="preserve">
     <value>PackagePart subclass must implement GetContentTypeCore method if passing a null value for the content type when PackagePart object is constructed.</value>
@@ -375,4 +375,4 @@
   <data name="FileContainsCorruptedData" xml:space="preserve">
     <value>File contains corrupted data.</value>
   </data>
-</root>
\ No newline at end of file
+</root>
diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs b/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs
index 5da904a7c6f9d4..a0127f539bc6c7 100644
--- a/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs
+++ b/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs
@@ -47,7 +47,7 @@ public static IPHostEntry GetHostEntry(IPAddress address)
             if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
             {
                 if (NetEventSource.Log.IsEnabled()) NetEventSource.Error(address, $"Invalid address '{address}'");
-                throw new ArgumentException(SR.Format(SR.net_invalid_ip_addr, nameof(address)));
+                throw new ArgumentException(SR.net_invalid_ip_addr, nameof(address));
             }
 
             IPHostEntry ipHostEntry = GetHostEntryCore(address, AddressFamily.Unspecified);
@@ -81,7 +81,7 @@ public static IPHostEntry GetHostEntry(string hostNameOrAddress, AddressFamily f
                 if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
                 {
                     if (NetEventSource.Log.IsEnabled()) NetEventSource.Error(address, $"Invalid address '{address}'");
-                    throw new ArgumentException(SR.Format(SR.net_invalid_ip_addr, nameof(hostNameOrAddress)));
+                    throw new ArgumentException(SR.net_invalid_ip_addr, nameof(hostNameOrAddress));
                 }
 
                 ipHostEntry = GetHostEntryCore(address, family);
@@ -207,7 +207,7 @@ public static IPAddress[] GetHostAddresses(string hostNameOrAddress, AddressFami
                 if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
                 {
                     if (NetEventSource.Log.IsEnabled()) NetEventSource.Error(address, $"Invalid address '{address}'");
-                    throw new ArgumentException(SR.Format(SR.net_invalid_ip_addr, nameof(hostNameOrAddress)));
+                    throw new ArgumentException(SR.net_invalid_ip_addr, nameof(hostNameOrAddress));
                 }
 
                 addresses = (family == AddressFamily.Unspecified || address.AddressFamily == family) ? new IPAddress[] { address } : Array.Empty<IPAddress>();
diff --git a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEventArgs.cs b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEventArgs.cs
index 6c79043631eb72..faf0d9f204c7cf 100644
--- a/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEventArgs.cs
+++ b/src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEventArgs.cs
@@ -153,7 +153,7 @@ public IList<ArraySegment<byte>>? BufferList
                         if (!_buffer.Equals(default))
                         {
                             // Can't have both set
-                            throw new ArgumentException(SR.Format(SR.net_ambiguousbuffers, nameof(Buffer)));
+                            throw new ArgumentException(SR.net_ambiguousbuffers);
                         }
 
                         // Copy the user-provided list into our internal buffer list,
@@ -358,7 +358,7 @@ public void SetBuffer(byte[]? buffer, int offset, int count)
                     // Can't have both Buffer and BufferList.
                     if (_bufferList != null)
                     {
-                        throw new ArgumentException(SR.Format(SR.net_ambiguousbuffers, nameof(BufferList)));
+                        throw new ArgumentException(SR.net_ambiguousbuffers);
                     }
 
                     // Offset and count can't be negative and the
@@ -391,7 +391,7 @@ public void SetBuffer(Memory<byte> buffer)
             {
                 if (buffer.Length != 0 && _bufferList != null)
                 {
-                    throw new ArgumentException(SR.Format(SR.net_ambiguousbuffers, nameof(BufferList)));
+                    throw new ArgumentException(SR.net_ambiguousbuffers);
                 }
 
                 _buffer = buffer;
@@ -559,7 +559,7 @@ internal void StartOperationAccept()
                 // Caller specified a buffer - see if it is large enough
                 if (_count < _acceptAddressBufferCount)
                 {
-                    throw new ArgumentException(SR.Format(SR.net_buffercounttoosmall, nameof(Count)));
+                    throw new ArgumentException(SR.net_buffercounttoosmall, nameof(Count));
                 }
             }
             else
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Hashtable.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Hashtable.cs
index 01b9cdb3c737ad..d311cd0c94bbde 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Collections/Hashtable.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Hashtable.cs
@@ -260,7 +260,7 @@ public Hashtable(int capacity, float loadFactor)
             if (capacity < 0)
                 throw new ArgumentOutOfRangeException(nameof(capacity), SR.ArgumentOutOfRange_NeedNonNegNum);
             if (!(loadFactor >= 0.1f && loadFactor <= 1.0f))
-                throw new ArgumentOutOfRangeException(nameof(loadFactor), SR.Format(SR.ArgumentOutOfRange_HashtableLoadFactor, .1, 1.0));
+                throw new ArgumentOutOfRangeException(nameof(loadFactor), SR.ArgumentOutOfRange_HashtableLoadFactor);
 
             // Based on perf work, .72 is the optimal load factor for this table.
             _loadFactor = 0.72f * loadFactor;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs
index f8d6e9c6ff114d..b54a5a50ba62ed 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs
@@ -3280,7 +3280,7 @@ private static bool AttributeTypeNamesMatch(Type attributeType, Type reflectedAt
                         }
                         else if (eventAttribute.EventId <= 0)
                         {
-                            manifest.ManifestError(SR.Format(SR.EventSource_NeedPositiveId, method.Name), true);
+                            manifest.ManifestError(SR.EventSource_NeedPositiveId, true);
                             continue;   // don't validate anything else for this event
                         }
                         if (method.Name.LastIndexOf('.') >= 0)
@@ -3501,7 +3501,7 @@ private static void AddProviderEnumKind(ManifestBuilder manifest, FieldInfo stat
 #endif
             return;
             Error:
-            manifest.ManifestError(SR.Format(SR.EventSource_EnumKindMismatch, staticField.Name, staticField.FieldType.Name, providerEnumKind));
+            manifest.ManifestError(SR.Format(SR.EventSource_EnumKindMismatch, staticField.FieldType.Name, providerEnumKind));
         }
 
         // Helper used by code:CreateManifestAndDescriptors to add a code:EventData descriptor for a method
@@ -3630,7 +3630,7 @@ private static void DebugCheckEvent(ref Dictionary<string, string>? eventsByName
 
             if (evtId < eventData.Length && eventData[evtId].Descriptor.EventId != 0)
             {
-                manifest.ManifestError(SR.Format(SR.EventSource_EventIdReused, evtName, evtId, eventData[evtId].Name), true);
+                manifest.ManifestError(SR.Format(SR.EventSource_EventIdReused, evtName, evtId), true);
             }
 
             // We give a task to things if they don't have one.
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/UnmanagedMemoryAccessor.cs b/src/libraries/System.Private.CoreLib/src/System/IO/UnmanagedMemoryAccessor.cs
index 0e53df433e78cc..78d0dab488a565 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/UnmanagedMemoryAccessor.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/UnmanagedMemoryAccessor.cs
@@ -319,7 +319,7 @@ public void Read<T>(long position, out T structure) where T : struct
                 }
                 else
                 {
-                    throw new ArgumentException(SR.Format(SR.Argument_NotEnoughBytesToRead, typeof(T)), nameof(position));
+                    throw new ArgumentException(SR.Argument_NotEnoughBytesToRead, nameof(position));
                 }
             }
 
@@ -561,7 +561,7 @@ public void Write<T>(long position, ref T structure) where T : struct
                 }
                 else
                 {
-                    throw new ArgumentException(SR.Format(SR.Argument_NotEnoughBytesToWrite, typeof(T)), nameof(position));
+                    throw new ArgumentException(SR.Argument_NotEnoughBytesToWrite, nameof(position));
                 }
             }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Random.cs b/src/libraries/System.Private.CoreLib/src/System/Random.cs
index 05766c724d2677..91070448823331 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Random.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Random.cs
@@ -192,7 +192,7 @@ protected virtual double Sample()
         }
 
         private static void ThrowMaxValueMustBeNonNegative() =>
-            throw new ArgumentOutOfRangeException("maxValue", SR.Format(SR.ArgumentOutOfRange_NeedNonNegNum, "maxValue"));
+            throw new ArgumentOutOfRangeException("maxValue", SR.ArgumentOutOfRange_NeedNonNegNum);
 
         private static void ThrowMinMaxValueSwapped() =>
             throw new ArgumentOutOfRangeException("minValue", SR.Format(SR.Argument_MinMaxValue, "minValue", "maxValue"));
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/DecoderReplacementFallback.cs b/src/libraries/System.Private.CoreLib/src/System/Text/DecoderReplacementFallback.cs
index 8f769f1c45bca6..34270ba3c30ade 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Text/DecoderReplacementFallback.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Text/DecoderReplacementFallback.cs
@@ -57,7 +57,7 @@ public DecoderReplacementFallback(string replacement)
                     break;
             }
             if (bFoundHigh)
-                throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequenceNoIndex, nameof(replacement)));
+                throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, nameof(replacement));
 
             _strDefault = replacement;
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/EncoderReplacementFallback.cs b/src/libraries/System.Private.CoreLib/src/System/Text/EncoderReplacementFallback.cs
index 5c93f4cc2cdb71..709695ce36dd11 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Text/EncoderReplacementFallback.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Text/EncoderReplacementFallback.cs
@@ -58,7 +58,7 @@ public EncoderReplacementFallback(string replacement)
                     break;
             }
             if (bFoundHigh)
-                throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequenceNoIndex, nameof(replacement)));
+                throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, nameof(replacement));
 
             _strDefault = replacement;
         }
diff --git a/src/libraries/System.Private.Xml/tests/Xslt/XslTransformApi/CXslTransform.cs b/src/libraries/System.Private.Xml/tests/Xslt/XslTransformApi/CXslTransform.cs
index 9f561b2554e00c..6c320a7295bcda 100644
--- a/src/libraries/System.Private.Xml/tests/Xslt/XslTransformApi/CXslTransform.cs
+++ b/src/libraries/System.Private.Xml/tests/Xslt/XslTransformApi/CXslTransform.cs
@@ -1234,7 +1234,7 @@ public void LoadGeneric12(InputType inputType, ReaderType readerType, TransformT
                     }
                     catch (System.InvalidOperationException e2)
                     {
-                        CheckExpectedError(e2, "system.xml", "Xslt_NoStylesheetLoaded", new string[] { "IDontExist.xsl" });
+                        CheckExpectedError(e2, "system.xml", "Xslt_NoStylesheetLoaded", new string[] { "" });
                         return;
                     }
                 }
diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/Internal/BlobHeap.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/Internal/BlobHeap.cs
index 302a6167c55630..abd9cf514babf3 100644
--- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/Internal/BlobHeap.cs
+++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/Internal/BlobHeap.cs
@@ -190,7 +190,7 @@ public string GetDocumentName(DocumentNameBlobHandle handle)
             int separator = blobReader.ReadByte();
             if (separator > 0x7f)
             {
-                throw new BadImageFormatException(SR.Format(SR.InvalidDocumentName, separator));
+                throw new BadImageFormatException(SR.InvalidDocumentName);
             }
 
             var pooledBuilder = PooledStringBuilder.GetInstance();
diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs
index 2d7395e2e83dda..79d11ebe76203e 100644
--- a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs
+++ b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs
@@ -310,7 +310,7 @@ internal static bool TryValidateParseStyleInteger(NumberStyles style, [NotNullWh
             // Check for undefined flags
             if ((style & InvalidNumberStyles) != 0)
             {
-                e = new ArgumentException(SR.Format(SR.Argument_InvalidNumberStyles, nameof(style)));
+                e = new ArgumentException(SR.Argument_InvalidNumberStyles, nameof(style));
                 return false;
             }
             if ((style & NumberStyles.AllowHexSpecifier) != 0)
diff --git a/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
index 4c99946a673e87..4577d05e6187cb 100644
--- a/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
@@ -178,7 +178,7 @@
     <value>The specified curve '{0}' or its parameters are not valid for this platform.</value>
   </data>
   <data name="Cryptography_InvalidCurveOid" xml:space="preserve">
-    <value>The specified Oid is not valid. The Oid.FriendlyName or Oid.Value property must be set.</value>
+    <value>The specified Oid ({0}) is not valid. The Oid.FriendlyName or Oid.Value property must be set.</value>
   </data>
   <data name="Cryptography_InvalidIVSize" xml:space="preserve">
     <value>Specified initialization vector (IV) does not match the block size for this algorithm.</value>
diff --git a/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/CspKeyContainerInfo.Windows.cs b/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/CspKeyContainerInfo.Windows.cs
index ce73894fb36e0c..cda387503b0f2f 100644
--- a/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/CspKeyContainerInfo.Windows.cs
+++ b/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/CspKeyContainerInfo.Windows.cs
@@ -210,7 +210,7 @@ public string UniqueKeyContainerName
                 {
                     if (throwOnNotFound)
                     {
-                        throw new CryptographicException(SR.Format(SR.Cryptography_CSP_NotFound, "Error"));
+                        throw new CryptographicException(SR.Cryptography_CSP_NotFound);
                     }
 
                     return null;
@@ -243,7 +243,7 @@ private object ReadDeviceParameterVerifyContext(int keyParam)
             {
                 if (hr != CapiHelper.S_OK)
                 {
-                    throw new CryptographicException(SR.Format(SR.Cryptography_CSP_NotFound, "Error"));
+                    throw new CryptographicException(SR.Cryptography_CSP_NotFound);
                 }
 
                 object retVal = CapiHelper.GetProviderParameter(safeProvHandle, parameters.KeyNumber, keyParam);
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Chain.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Chain.cs
index dbefadab573347..7260b772f46ced 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Chain.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Chain.cs
@@ -117,13 +117,13 @@ internal bool Build(X509Certificate2 certificate, bool throwOnException)
                 if (_chainPolicy != null && _chainPolicy.CustomTrustStore != null)
                 {
                     if (_chainPolicy.TrustMode == X509ChainTrustMode.System && _chainPolicy.CustomTrustStore.Count > 0)
-                        throw new CryptographicException(SR.Cryptography_CustomTrustCertsInSystemMode, nameof(_chainPolicy.TrustMode));
+                        throw new CryptographicException(SR.Cryptography_CustomTrustCertsInSystemMode);
 
                     foreach (X509Certificate2 customCertificate in _chainPolicy.CustomTrustStore)
                     {
                         if (customCertificate == null || customCertificate.Handle == IntPtr.Zero)
                         {
-                            throw new CryptographicException(SR.Cryptography_InvalidTrustCertificate, nameof(_chainPolicy.CustomTrustStore));
+                            throw new CryptographicException(SR.Cryptography_InvalidTrustCertificate);
                         }
                     }
                 }
diff --git a/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx
index 84a24a8fc9ef46..dc30b357b0b388 100644
--- a/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx
@@ -205,7 +205,7 @@
     <value>The specified key parameters are not valid. Q.X and Q.Y, or D, must be specified. Q.X, Q.Y must be the same length. If D is specified it must be the same length as Q.X and Q.Y if also specified for named curves or the same length as Order for explicit curves.</value>
   </data>
   <data name="Cryptography_InvalidCurveOid" xml:space="preserve">
-    <value>The specified Oid is not valid. The Oid.FriendlyName or Oid.Value property must be set.</value>
+    <value>The specified Oid ({0}) is not valid. The Oid.FriendlyName or Oid.Value property must be set.</value>
   </data>
   <data name="Cryptography_InvalidDsaParameters_MismatchedPGY" xml:space="preserve">
     <value>The specified DSA parameters are not valid; P, G and Y must be the same length (the key size).</value>
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECCurve.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECCurve.cs
index a14e816f799df6..5876e483bcb6de 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECCurve.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECCurve.cs
@@ -79,7 +79,7 @@ private set
                     throw new ArgumentNullException(nameof(Oid));
 
                 if (string.IsNullOrEmpty(value.Value) && string.IsNullOrEmpty(value.FriendlyName))
-                    throw new ArgumentException(SR.Cryptography_InvalidCurveOid);
+                    throw new ArgumentException(SR.Format(SR.Cryptography_InvalidCurveOid, value.Value));
 
                 _oid = value;
             }
@@ -197,7 +197,7 @@ public void Validate()
                 if (Oid == null ||
                     (string.IsNullOrEmpty(Oid.FriendlyName) && string.IsNullOrEmpty(Oid.Value)))
                 {
-                    throw new CryptographicException(SR.Cryptography_InvalidCurveOid);
+                    throw new CryptographicException(SR.Format(SR.Cryptography_InvalidCurveOid, Oid?.Value));
                 }
             }
             else if (IsExplicit)
diff --git a/src/libraries/System.Text.Encoding/tests/Fallback/DecoderReplacementFallbackTests.cs b/src/libraries/System.Text.Encoding/tests/Fallback/DecoderReplacementFallbackTests.cs
index 51d3f2d074e722..7bb51d8a22dd8c 100644
--- a/src/libraries/System.Text.Encoding/tests/Fallback/DecoderReplacementFallbackTests.cs
+++ b/src/libraries/System.Text.Encoding/tests/Fallback/DecoderReplacementFallbackTests.cs
@@ -36,12 +36,12 @@ public void Ctor_Invalid()
             AssertExtensions.Throws<ArgumentNullException>("replacement", () => new DecoderReplacementFallback(null));
 
             // Invalid surrogate pair
-            AssertExtensions.Throws<ArgumentException>(null, () => new DecoderReplacementFallback("\uD800"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new DecoderReplacementFallback("\uD800a"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new DecoderReplacementFallback("\uDC00"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new DecoderReplacementFallback("a\uDC00"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new DecoderReplacementFallback("\uDC00\uDC00"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new DecoderReplacementFallback("\uD800\uD800"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new DecoderReplacementFallback("\uD800"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new DecoderReplacementFallback("\uD800a"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new DecoderReplacementFallback("\uDC00"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new DecoderReplacementFallback("a\uDC00"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new DecoderReplacementFallback("\uDC00\uDC00"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new DecoderReplacementFallback("\uD800\uD800"));
         }
 
         public static IEnumerable<object[]> Equals_TestData()
diff --git a/src/libraries/System.Text.Encoding/tests/Fallback/EncoderReplacementFallbackTests.cs b/src/libraries/System.Text.Encoding/tests/Fallback/EncoderReplacementFallbackTests.cs
index 45709bb693e22b..1fe7b2499ab161 100644
--- a/src/libraries/System.Text.Encoding/tests/Fallback/EncoderReplacementFallbackTests.cs
+++ b/src/libraries/System.Text.Encoding/tests/Fallback/EncoderReplacementFallbackTests.cs
@@ -36,12 +36,12 @@ public void Ctor_Invalid()
             AssertExtensions.Throws<ArgumentNullException>("replacement", () => new EncoderReplacementFallback(null));
 
             // Invalid surrogate pair
-            AssertExtensions.Throws<ArgumentException>(null, () => new EncoderReplacementFallback("\uD800"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new EncoderReplacementFallback("\uD800a"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new EncoderReplacementFallback("\uDC00"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new EncoderReplacementFallback("a\uDC00"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new EncoderReplacementFallback("\uDC00\uDC00"));
-            AssertExtensions.Throws<ArgumentException>(null, () => new EncoderReplacementFallback("\uD800\uD800"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new EncoderReplacementFallback("\uD800"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new EncoderReplacementFallback("\uD800a"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new EncoderReplacementFallback("\uDC00"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new EncoderReplacementFallback("a\uDC00"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new EncoderReplacementFallback("\uDC00\uDC00"));
+            AssertExtensions.Throws<ArgumentException>("replacement", () => new EncoderReplacementFallback("\uD800\uD800"));
         }
 
         public static IEnumerable<object[]> Equals_TestData()

From 0bf7e14c80da09fa92e3cdf65b46dbc4d14bd0b5 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 25 Jan 2022 18:23:52 -0500
Subject: [PATCH 072/161] Add Regex.Count string overloads (#64289)

---
 .../ref/System.Text.RegularExpressions.cs     |   4 +
 .../src/System.Text.RegularExpressions.csproj |   1 +
 .../Text/RegularExpressions/Regex.Count.cs    |  64 ++++++++++
 .../tests/Regex.Count.Tests.cs                | 120 ++++++++++++++++++
 ...ystem.Text.RegularExpressions.Tests.csproj |   1 +
 5 files changed, 190 insertions(+)
 create mode 100644 src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Count.cs
 create mode 100644 src/libraries/System.Text.RegularExpressions/tests/Regex.Count.Tests.cs

diff --git a/src/libraries/System.Text.RegularExpressions/ref/System.Text.RegularExpressions.cs b/src/libraries/System.Text.RegularExpressions/ref/System.Text.RegularExpressions.cs
index 75ed12a69731f5..251d595081072d 100644
--- a/src/libraries/System.Text.RegularExpressions/ref/System.Text.RegularExpressions.cs
+++ b/src/libraries/System.Text.RegularExpressions/ref/System.Text.RegularExpressions.cs
@@ -161,6 +161,10 @@ public static void CompileToAssembly(System.Text.RegularExpressions.RegexCompila
         public static void CompileToAssembly(System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[]? attributes) { }
         [System.ObsoleteAttribute("Regex.CompileToAssembly is obsolete and not supported. Use the RegexGeneratorAttribute with the regular expression source generator instead.", DiagnosticId = "SYSLIB0036", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         public static void CompileToAssembly(System.Text.RegularExpressions.RegexCompilationInfo[] regexinfos, System.Reflection.AssemblyName assemblyname, System.Reflection.Emit.CustomAttributeBuilder[]? attributes, string? resourceFile) { }
+        public int Count(string input) { throw null; }
+        public static int Count(string input, [System.Diagnostics.CodeAnalysis.StringSyntax(System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex)] string pattern) { throw null; }
+        public static int Count(string input, [System.Diagnostics.CodeAnalysis.StringSyntax(System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex, "options")] string pattern, System.Text.RegularExpressions.RegexOptions options) { throw null; }
+        public static int Count(string input, [System.Diagnostics.CodeAnalysis.StringSyntax(System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.Regex, "options")] string pattern, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { throw null; }
         public static string Escape(string str) { throw null; }
         public string[] GetGroupNames() { throw null; }
         public int[] GetGroupNumbers() { throw null; }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj b/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj
index acda3098b795ce..cfe2c82d38d1a5 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj
+++ b/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj
@@ -18,6 +18,7 @@
     <Compile Include="System\Text\RegularExpressions\MatchCollection.cs" />
     <Compile Include="System\Text\RegularExpressions\Regex.cs" />
     <Compile Include="System\Text\RegularExpressions\Regex.Cache.cs" />
+    <Compile Include="System\Text\RegularExpressions\Regex.Count.cs" />
     <Compile Include="System\Text\RegularExpressions\Regex.Debug.cs" />
     <Compile Include="System\Text\RegularExpressions\Regex.Match.cs" />
     <Compile Include="System\Text\RegularExpressions\Regex.Replace.cs" />
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Count.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Count.cs
new file mode 100644
index 00000000000000..18c08ee3242e2d
--- /dev/null
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Count.cs
@@ -0,0 +1,64 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Text.RegularExpressions
+{
+    public partial class Regex
+    {
+        /// <summary>Searches an input string for all occurrences of a regular expression and returns the number of matches.</summary>
+        /// <param name="input">The string to search for a match.</param>
+        /// <returns>The number of matches.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="input"/> is null.</exception>
+        public int Count(string input)
+        {
+            if (input is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
+            }
+
+            int count = 0;
+
+            Run(input, 0, ref count, static (ref int count, Match match) =>
+            {
+                count++;
+                return true;
+            }, reuseMatchObject: true);
+
+            return count;
+        }
+
+        /// <summary>Searches an input string for all occurrences of a regular expression and returns the number of matches.</summary>
+        /// <param name="input">The string to search for a match.</param>
+        /// <param name="pattern">The regular expression pattern to match.</param>
+        /// <returns>The number of matches.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="input"/> or <paramref name="pattern"/> is null.</exception>
+        /// <exception cref="RegexParseException">A regular expression parsing error occurred.</exception>
+        public static int Count(string input, [StringSyntax(StringSyntaxAttribute.Regex)] string pattern) =>
+            RegexCache.GetOrAdd(pattern).Count(input);
+
+        /// <summary>Searches an input string for all occurrences of a regular expression and returns the number of matches.</summary>
+        /// <param name="input">The string to search for a match.</param>
+        /// <param name="pattern">The regular expression pattern to match.</param>
+        /// <param name="options">A bitwise combination of the enumeration values that specify options for matching.</param>
+        /// <returns>The number of matches.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="input"/> or <paramref name="pattern"/> is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="options"/> is not a valid bitwise combination of RegexOptions values.</exception>
+        /// <exception cref="RegexParseException">A regular expression parsing error occurred.</exception>
+        public static int Count(string input, [StringSyntax(StringSyntaxAttribute.Regex, "options")] string pattern, RegexOptions options) =>
+            RegexCache.GetOrAdd(pattern, options, s_defaultMatchTimeout).Count(input);
+
+        /// <summary>Searches an input string for all occurrences of a regular expression and returns the number of matches.</summary>
+        /// <param name="input">The string to search for a match.</param>
+        /// <param name="pattern">The regular expression pattern to match.</param>
+        /// <param name="options">A bitwise combination of the enumeration values that specify options for matching.</param>
+        /// <param name="matchTimeout">A time-out interval, or <see cref="InfiniteMatchTimeout"/> to indicate that the method should not time out.</param>
+        /// <returns>The number of matches.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="input"/> or <paramref name="pattern"/> is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="options"/> is not a valid bitwise combination of RegexOptions values, or <paramref name="matchTimeout"/> is negative, zero, or greater than approximately 24 days.</exception>
+        /// <exception cref="RegexParseException">A regular expression parsing error occurred.</exception>
+        public static int Count(string input, [StringSyntax(StringSyntaxAttribute.Regex, "options")] string pattern, RegexOptions options, TimeSpan matchTimeout) =>
+            RegexCache.GetOrAdd(pattern, options, matchTimeout).Count(input);
+    }
+}
diff --git a/src/libraries/System.Text.RegularExpressions/tests/Regex.Count.Tests.cs b/src/libraries/System.Text.RegularExpressions/tests/Regex.Count.Tests.cs
new file mode 100644
index 00000000000000..272cbb143d69d4
--- /dev/null
+++ b/src/libraries/System.Text.RegularExpressions/tests/Regex.Count.Tests.cs
@@ -0,0 +1,120 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace System.Text.RegularExpressions.Tests
+{
+    public class RegexCountTests
+    {
+        [Theory]
+        [MemberData(nameof(Count_ReturnsExpectedCount_TestData))]
+        public async Task Count_ReturnsExpectedCount(RegexEngine engine, string pattern, string input, RegexOptions options, int expectedCount)
+        {
+            Regex r = await RegexHelpers.GetRegexAsync(engine, pattern, options);
+            Assert.Equal(expectedCount, r.Count(input));
+            Assert.Equal(r.Count(input), r.Matches(input).Count);
+
+            if (options == RegexOptions.None && engine == RegexEngine.Interpreter)
+            {
+                Assert.Equal(expectedCount, Regex.Count(input, pattern));
+            }
+
+            switch (engine)
+            {
+                case RegexEngine.Interpreter:
+                case RegexEngine.Compiled:
+                case RegexEngine.NonBacktracking:
+                    RegexOptions engineOptions = RegexHelpers.OptionsFromEngine(engine);
+                    Assert.Equal(expectedCount, Regex.Count(input, pattern, options | engineOptions));
+                    Assert.Equal(expectedCount, Regex.Count(input, pattern, options | engineOptions, Regex.InfiniteMatchTimeout));
+                    break;
+            }
+        }
+
+        public static IEnumerable<object[]> Count_ReturnsExpectedCount_TestData()
+        {
+            foreach (RegexEngine engine in RegexHelpers.AvailableEngines)
+            {
+                yield return new object[] { engine, @"", "", RegexOptions.None, 1 };
+                yield return new object[] { engine, @"", "a", RegexOptions.None, 2 };
+                yield return new object[] { engine, @"", "ab", RegexOptions.None, 3 };
+
+                yield return new object[] { engine, @"\w", "", RegexOptions.None, 0 };
+                yield return new object[] { engine, @"\w", "a", RegexOptions.None, 1 };
+                yield return new object[] { engine, @"\w", "ab", RegexOptions.None, 2 };
+
+                yield return new object[] { engine, @"\b\w+\b", "abc def ghi jkl", RegexOptions.None, 4 };
+
+                yield return new object[] { engine, @"A", "", RegexOptions.IgnoreCase, 0 };
+                yield return new object[] { engine, @"A", "a", RegexOptions.IgnoreCase, 1 };
+                yield return new object[] { engine, @"A", "aAaA", RegexOptions.IgnoreCase, 4 };
+
+                yield return new object[] { engine, @".", "\n\n\n", RegexOptions.None, 0 };
+                yield return new object[] { engine, @".", "\n\n\n", RegexOptions.Singleline, 3 };
+            }
+        }
+
+        [Fact]
+        public void Count_InvalidArguments_Throws()
+        {
+            // input is null
+            AssertExtensions.Throws<ArgumentNullException>("input", () => new Regex("pattern").Count(null));
+            AssertExtensions.Throws<ArgumentNullException>("input", () => Regex.Count(null, @"pattern"));
+            AssertExtensions.Throws<ArgumentNullException>("input", () => Regex.Count(null, @"pattern", RegexOptions.None));
+            AssertExtensions.Throws<ArgumentNullException>("input", () => Regex.Count(null, @"pattern", RegexOptions.None, TimeSpan.FromMilliseconds(1)));
+
+            // pattern is null
+            AssertExtensions.Throws<ArgumentNullException>("pattern", () => Regex.Count("input", null));
+            AssertExtensions.Throws<ArgumentNullException>("pattern", () => Regex.Count("input", null, RegexOptions.None));
+            AssertExtensions.Throws<ArgumentNullException>("pattern", () => Regex.Count("input", null, RegexOptions.None, TimeSpan.FromMilliseconds(1)));
+
+            // pattern is invalid
+#pragma warning disable RE0001 // invalid regex pattern
+            AssertExtensions.Throws<RegexParseException>(() => Regex.Count("input", @"[abc"));
+            AssertExtensions.Throws<RegexParseException>(() => Regex.Count("input", @"[abc", RegexOptions.None));
+            AssertExtensions.Throws<RegexParseException>(() => Regex.Count("input", @"[abc", RegexOptions.None, TimeSpan.FromMilliseconds(1)));
+#pragma warning restore RE0001
+
+            // options is invalid
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.Count("input", @"[abc]", (RegexOptions)(-1)));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.Count("input", @"[abc]", (RegexOptions)(-1), TimeSpan.FromMilliseconds(1)));
+
+            // matchTimeout is invalid
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("matchTimeout", () => Regex.Count("input", @"[abc]", RegexOptions.None, TimeSpan.FromMilliseconds(-2)));
+        }
+
+        [Theory]
+        [MemberData(nameof(RegexHelpers.AvailableEngines_MemberData), MemberType = typeof(RegexHelpers))]
+        public async Task Count_Timeout_ThrowsAfterTooLongExecution(RegexEngine engine)
+        {
+            if (RegexHelpers.IsNonBacktracking(engine))
+            {
+                // Test relies on backtracking taking a long time
+                return;
+            }
+
+            const string Pattern = @"^(\w+\s?)*$";
+            const string Input = "An input string that takes a very very very very very very very very very very very long time!";
+
+            Regex r = await RegexHelpers.GetRegexAsync(engine, Pattern, RegexOptions.None, TimeSpan.FromMilliseconds(1));
+
+            Stopwatch sw = Stopwatch.StartNew();
+            Assert.Throws<RegexMatchTimeoutException>(() => r.Count(Input));
+            Assert.InRange(sw.Elapsed.TotalSeconds, 0, 10); // arbitrary upper bound that should be well above what's needed with a 1ms timeout
+
+            switch (engine)
+            {
+                case RegexEngine.Interpreter:
+                case RegexEngine.Compiled:
+                    sw = Stopwatch.StartNew();
+                    Assert.Throws<RegexMatchTimeoutException>(() => Regex.Count(Input, Pattern, RegexHelpers.OptionsFromEngine(engine), TimeSpan.FromMilliseconds(1)));
+                    Assert.InRange(sw.Elapsed.TotalSeconds, 0, 10); // arbitrary upper bound that should be well above what's needed with a 1ms timeout
+                    break;
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Text.RegularExpressions/tests/System.Text.RegularExpressions.Tests.csproj b/src/libraries/System.Text.RegularExpressions/tests/System.Text.RegularExpressions.Tests.csproj
index 9641f9665a175c..d95fa07ad73f16 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/System.Text.RegularExpressions.Tests.csproj
+++ b/src/libraries/System.Text.RegularExpressions/tests/System.Text.RegularExpressions.Tests.csproj
@@ -41,6 +41,7 @@
     <PackageReference Include="System.Text.Json" Version="$(SystemTextJsonVersion)" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == '$(NetCoreAppCurrent)'">
+    <Compile Include="Regex.Count.Tests.cs" />
     <Compile Include="RegexAssert.netcoreapp.cs" />
     <Compile Include="RegexParserTests.netcoreapp.cs" />
     <Compile Include="GroupCollectionReadOnlyDictionaryTests.cs" />

From b5714997652ed38b28a14365b144d12efb420839 Mon Sep 17 00:00:00 2001
From: Jan Kotas <jkotas@microsoft.com>
Date: Tue, 25 Jan 2022 17:31:27 -0800
Subject: [PATCH 073/161] Clarify purpose of PDB Document hashing (#64306)

Fixes #63505
---
 docs/design/specs/PortablePdb-Metadata.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/design/specs/PortablePdb-Metadata.md b/docs/design/specs/PortablePdb-Metadata.md
index 811af00510bea7..c1d8e3c4420660 100644
--- a/docs/design/specs/PortablePdb-Metadata.md
+++ b/docs/design/specs/PortablePdb-Metadata.md
@@ -64,6 +64,8 @@ There shall be no duplicate rows in the _Document_ table, based upon document na
 
 _Name_ shall not be nil. It can however encode an empty name string.
 
+_Hash_ is the file content hashed using the specified _HashAlgorithm_. It is used to validate that a source file matches the one used by the compiler when compiling the source code.
+
 The values for which field _Language_ has a defined meaning are listed in the following tables along with the corresponding interpretation:
 
 | _Language_ field value               | language     |

From 518548b96b3369ceb3c54dd62e6cf55e2c5a4ce3 Mon Sep 17 00:00:00 2001
From: Robert Henry <robhenry@microsoft.com>
Date: Tue, 25 Jan 2022 17:38:52 -0800
Subject: [PATCH 074/161] Fix arm64/PInvoke so that NESTED_ENTRY/NESTED_END
 labels match. (#64296)

This was exposed by building on arm64 with gcc-12,
wherein the assembler complained about not being able
to evaluate the constant expression for .size for the symbol
on NESTED_END.  Since the symbol on NESTED_END is not
referenced anywhere else in the code base,
I concluded that it was wrong, and NESTED_ENTRY was right.

I have not tested this on anything but arm64 + gcc-12
---
 src/coreclr/nativeaot/Runtime/arm64/PInvoke.S   | 2 +-
 src/coreclr/nativeaot/Runtime/arm64/PInvoke.asm | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S b/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S
index f66851461f278f..4d3fbbbce2216e 100644
--- a/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S
+++ b/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S
@@ -188,7 +188,7 @@ NoAbort:
         EPILOG_RESTORE_REG_PAIR_INDEXED   fp, lr, 0xA0
         EPILOG_RETURN
 
-    NESTED_END RhpReversePInvokeTrapThread
+    NESTED_END RhpReversePInvokeAttachOrTrapThread, _TEXT
 
 //
 // RhpPInvoke
diff --git a/src/coreclr/nativeaot/Runtime/arm64/PInvoke.asm b/src/coreclr/nativeaot/Runtime/arm64/PInvoke.asm
index 7692bfa8341beb..4bc165aef04505 100644
--- a/src/coreclr/nativeaot/Runtime/arm64/PInvoke.asm
+++ b/src/coreclr/nativeaot/Runtime/arm64/PInvoke.asm
@@ -180,7 +180,7 @@ NoAbort
         EPILOG_RESTORE_REG_PAIR   fp, lr, #0xA0!
         EPILOG_RETURN
 
-    NESTED_END RhpReversePInvokeTrapThread
+    NESTED_END RhpReversePInvokeAttachOrTrapThread
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

From cfd725fcd1d446950efd8a7751a78b83f3b3e2c1 Mon Sep 17 00:00:00 2001
From: Andrew Au <andrewau@microsoft.com>
Date: Tue, 25 Jan 2022 19:02:08 -0800
Subject: [PATCH 075/161] When decommitting, leaving one instead of two pages
 in regions case. (#64243)

---
 src/coreclr/gc/gc.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp
index bc4c11771f2b13..4842346ad26af4 100644
--- a/src/coreclr/gc/gc.cpp
+++ b/src/coreclr/gc/gc.cpp
@@ -11601,10 +11601,11 @@ void gc_heap::decommit_heap_segment (heap_segment* seg)
 
     dprintf (3, ("Decommitting heap segment %Ix(%Ix)", (size_t)seg, heap_segment_mem (seg)));
 
-#ifdef BACKGROUND_GC
+#if defined(BACKGROUND_GC) && !defined(USE_REGIONS)
     page_start += OS_PAGE_SIZE;
-#endif //BACKGROUND_GC
+#endif //BACKGROUND_GC && !USE_REGIONS
 
+    assert (heap_segment_committed (seg) >= page_start);
     size_t size = heap_segment_committed (seg) - page_start;
     bool decommit_succeeded_p = virtual_decommit (page_start, size, heap_segment_oh (seg), heap_number);
 

From 9d3ff2659b820f5fa7bf8223f99f54d0ffb34cbc Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 25 Jan 2022 22:32:11 -0500
Subject: [PATCH 076/161] Ensure that canceled Task.Delays invoke continuations
 asynchronously from Cancel (#64217)

---
 .../src/System/Threading/Tasks/Task.cs         | 14 ++++++++++++++
 .../tests/Task/TaskRtTests.cs                  | 18 ++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs
index 6e319542ce4880..f5a4becbd73b40 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs
@@ -5627,6 +5627,20 @@ internal DelayPromiseWithCancellation(uint millisecondsDelay, CancellationToken
                 _registration = token.UnsafeRegister(static (state, cancellationToken) =>
                 {
                     var thisRef = (DelayPromiseWithCancellation)state!;
+
+                    // Normally RunContinuationsAsynchronously is set at construction time.  We don't want to
+                    // set it at construction because we want the timer firing (already on a thread pool thread with
+                    // a stack in which it's fine to execute arbitrary code) to synchronously invoke any continuations
+                    // from this task.  However, a cancellation request will come synchronously from a call to
+                    // CancellationTokenSource.Cancel, and we don't want to invoke arbitrary continuations from
+                    // this delay task as part of that Cancel call.  As such, we set RunContinuationsAsynchronously
+                    // after the fact, only when the task is being completed due to cancellation.  There is a race
+                    // condition here, such that if the timer also fired concurrently, it might win, in which case
+                    // it might also observe this RunContinuationsAsynchronously, but that's benign.  An alternative
+                    // is to make the whole cancellation registration queue, but that's visible in that the Task's
+                    // IsCompleted wouldn't be set synchronously as part of IsCompleted.
+                    thisRef.AtomicStateUpdate((int)TaskCreationOptions.RunContinuationsAsynchronously, 0);
+
                     if (thisRef.TrySetCanceled(cancellationToken))
                     {
                         thisRef.Cleanup();
diff --git a/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs b/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs
index e763ae63a43d4e..ffb2437aa4b3e1 100644
--- a/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs
+++ b/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs
@@ -691,6 +691,24 @@ public static void RunDelayTests_NegativeCases()
             }
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        public static void TaskDelay_Cancellation_ContinuationsInvokedAsynchronously()
+        {
+            var cts = new CancellationTokenSource();
+
+            var tl = new ThreadLocal<int>();
+            Task c = Task.Delay(-1, cts.Token).ContinueWith(_ =>
+            {
+                Assert.Equal(0, tl.Value);
+            }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+
+            tl.Value = 42;
+            cts.Cancel();
+            tl.Value = 0;
+
+            c.GetAwaiter().GetResult();
+        }
+
         // Test that exceptions are properly wrapped when thrown in various scenarios.
         // Make sure that "indirect" logic does not add superfluous exception wrapping.
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]

From 82ff4f89e5997ade30ac1a9de8f343c321dd10a9 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <maryam.ariyan@microsoft.com>
Date: Tue, 25 Jan 2022 19:32:45 -0800
Subject: [PATCH 077/161] Add gen folder moving gen projects from src folder
 (#64231)

---
 ...rosoft.Extensions.Logging.Abstractions.sln | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln b/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln
index bf9829d652330d..6f3c58066d303b 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln
@@ -1,9 +1,12 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32111.311
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{79CE8C7E-A4AF-413C-A54D-86F17073559C}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Logging.Generators", "gen\Microsoft.Extensions.Logging.Generators.Roslyn3.11.csproj", "{1491B9C9-955D-4DB0-B1D5-70137A78EAAE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Logging.Generators.Roslyn3.11", "gen\Microsoft.Extensions.Logging.Generators.Roslyn3.11.csproj", "{1491B9C9-955D-4DB0-B1D5-70137A78EAAE}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Logging.Generators", "gen\Microsoft.Extensions.Logging.Generators.Roslyn4.0.csproj", "{A5439E79-96D6-4F02-8DD0-23DFF979851D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Logging.Generators.Roslyn4.0", "gen\Microsoft.Extensions.Logging.Generators.Roslyn4.0.csproj", "{A5439E79-96D6-4F02-8DD0-23DFF979851D}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Logging.Abstractions", "ref\Microsoft.Extensions.Logging.Abstractions.csproj", "{7F536552-0E2A-4642-B7CF-863727C2F9CD}"
 EndProject
@@ -23,6 +26,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{548DF5F7-790
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{7631380A-FB73-4241-9987-0891A21E9769}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{03F31CEE-D63E-4E7F-949F-139B33DC3385}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -71,14 +76,14 @@ Global
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{79CE8C7E-A4AF-413C-A54D-86F17073559C} = {4DE63935-DCA9-4D63-9C1F-AAE79C89CA8B}
+		{1491B9C9-955D-4DB0-B1D5-70137A78EAAE} = {03F31CEE-D63E-4E7F-949F-139B33DC3385}
+		{A5439E79-96D6-4F02-8DD0-23DFF979851D} = {03F31CEE-D63E-4E7F-949F-139B33DC3385}
+		{7F536552-0E2A-4642-B7CF-863727C2F9CD} = {7631380A-FB73-4241-9987-0891A21E9769}
+		{75C579F7-F20B-41F1-8CAF-641DE7ADA4EE} = {548DF5F7-790C-4A1C-89EB-BD904CA1BA86}
 		{C333EC5A-F386-4A01-AE20-12D499551304} = {4DE63935-DCA9-4D63-9C1F-AAE79C89CA8B}
 		{1CB869A7-2EEC-4A53-9C33-DF9E0C75825B} = {4DE63935-DCA9-4D63-9C1F-AAE79C89CA8B}
-		{1491B9C9-955D-4DB0-B1D5-70137A78EAAE} = {548DF5F7-790C-4A1C-89EB-BD904CA1BA86}
-		{A5439E79-96D6-4F02-8DD0-23DFF979851D} = {548DF5F7-790C-4A1C-89EB-BD904CA1BA86}
-		{75C579F7-F20B-41F1-8CAF-641DE7ADA4EE} = {548DF5F7-790C-4A1C-89EB-BD904CA1BA86}
-		{F8CF3192-B902-4631-972A-C405FDECC48D} = {548DF5F7-790C-4A1C-89EB-BD904CA1BA86}
-		{7F536552-0E2A-4642-B7CF-863727C2F9CD} = {7631380A-FB73-4241-9987-0891A21E9769}
 		{DAA1349E-960E-49EB-81F3-FF4F99D8A325} = {7631380A-FB73-4241-9987-0891A21E9769}
+		{F8CF3192-B902-4631-972A-C405FDECC48D} = {548DF5F7-790C-4A1C-89EB-BD904CA1BA86}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {450DA749-CBDC-4BDC-950F-8A491CF59D49}

From 8770287f77c6b218c0d30536544531ba8597faf4 Mon Sep 17 00:00:00 2001
From: Robert Henry <robhenry@microsoft.com>
Date: Tue, 25 Jan 2022 20:16:44 -0800
Subject: [PATCH 078/161] Fix minor typos in GC documentation. (#64298)

---
 src/coreclr/gc/gcconfig.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/coreclr/gc/gcconfig.h b/src/coreclr/gc/gcconfig.h
index 886ea17743880d..d727a4685c527e 100644
--- a/src/coreclr/gc/gcconfig.h
+++ b/src/coreclr/gc/gcconfig.h
@@ -87,8 +87,8 @@ class GCConfigStringHolder
     INT_CONFIG   (SegmentSize,            "GCSegmentSize",          NULL,                             0,                 "Specifies the managed heap segment size")                                                \
     INT_CONFIG   (LatencyMode,            "GCLatencyMode",          NULL,                             -1,                "Specifies the GC latency mode - batch, interactive or low latency (note that the same "  \
                                                                                                                          "thing can be specified via API which is the supported way")                              \
-    INT_CONFIG   (LatencyLevel,           "GCLatencyLevel",         NULL,                             1,                 "Specifies the GC latency level that you want to optimize for. Must be a number from 0"   \
-                                                                                                                         "3. See documentation for more details on each level.")                                   \
+    INT_CONFIG   (LatencyLevel,           "GCLatencyLevel",         NULL,                             1,                 "Specifies the GC latency level that you want to optimize for. Must be a number from 0 "  \
+                                                                                                                         "to 3. See documentation for more details on each level.")                                \
     INT_CONFIG   (LogFileSize,            "GCLogFileSize",          NULL,                             0,                 "Specifies the GC log file size")                                                         \
     INT_CONFIG   (CompactRatio,           "GCCompactRatio",         NULL,                             0,                 "Specifies the ratio compacting GCs vs sweeping")                                         \
     INT_CONFIG   (GCHeapAffinitizeMask,   "GCHeapAffinitizeMask",   "System.GC.HeapAffinitizeMask",   0,                 "Specifies processor mask for Server GC threads")                                         \
@@ -117,7 +117,7 @@ class GCConfigStringHolder
     INT_CONFIG   (BGCFLkd,                "BGCFLkd",                NULL,                             11,                "Specifies kd for above goal tuning")                                                     \
     INT_CONFIG   (BGCFLff,                "BGCFLff",                NULL,                             100,               "Specifies ff ratio")                                                                     \
     INT_CONFIG   (BGCFLSmoothFactor,      "BGCFLSmoothFactor",      NULL,                             150,               "Smoothing over these")                                                                   \
-    INT_CONFIG   (BGCFLGradualD,          "BGCFLGradualD",          NULL,                             0,                 "Enable gradual D instead of cutting of at the value")                                    \
+    INT_CONFIG   (BGCFLGradualD,          "BGCFLGradualD",          NULL,                             0,                 "Enable gradual D instead of cutting off at the value")                                   \
     INT_CONFIG   (BGCMLkp,                "BGCMLkp",                NULL,                             1000,              "Specifies kp for ML tuning")                                                             \
     INT_CONFIG   (BGCMLki,                "BGCMLki",                NULL,                             16,                "Specifies ki for ML tuning")                                                             \
     INT_CONFIG   (BGCFLEnableKi,          "BGCFLEnableKi",          NULL,                             1,                 "Enables ki for above goal tuning")                                                       \

From 43ceed5514ca93242ff41f9f1ee53fc108c5dc1b Mon Sep 17 00:00:00 2001
From: Egor Chesakov <Egor.Chesakov@microsoft.com>
Date: Tue, 25 Jan 2022 20:49:13 -0800
Subject: [PATCH 079/161] Explicitly specify four subdirectories to use as part
 of the paths for -pmi_path arguments and expand the paths on a remote machine
 in src/coreclr/scripts/superpmi-collect.proj (#64308)

---
 src/coreclr/scripts/superpmi-collect.proj | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/coreclr/scripts/superpmi-collect.proj b/src/coreclr/scripts/superpmi-collect.proj
index 4a6edd8b5923b8..8d59a8218ae884 100644
--- a/src/coreclr/scripts/superpmi-collect.proj
+++ b/src/coreclr/scripts/superpmi-collect.proj
@@ -44,7 +44,10 @@
     -->
 
   <ItemGroup>
-    <PmiPathDirectories Include="$([System.IO.Directory]::GetDirectories($(SuperPMIDirectory)))" />
+    <PmiPathDirectories Include="R2RDump" />
+    <PmiPathDirectories Include="R2RTest" />
+    <PmiPathDirectories Include="crossgen2" />
+    <PmiPathDirectories Include="xunit" />
   </ItemGroup>
 
   <PropertyGroup Condition="'$(AGENT_OS)' == 'Windows_NT'">
@@ -59,7 +62,7 @@
     <OutputMchPath>%HELIX_WORKITEM_UPLOAD_ROOT%</OutputMchPath>
     <!-- Workaround until https://github.com/dotnet/arcade/pull/6179 is not available -->
     <HelixResultsDestinationDir>$(BUILD_SOURCESDIRECTORY)\artifacts\helixresults</HelixResultsDestinationDir>
-    <WorkItemCommand>$(SuperPMIDirectory)\superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)\pmi.dll -pmi_path @(PmiPathDirectories->'%(FullPath)', ' ')</WorkItemCommand>
+    <WorkItemCommand>$(SuperPMIDirectory)\superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)\pmi.dll -pmi_path @(PmiPathDirectories->'$(SuperPMIDirectory)\%(Identity)', ' ')</WorkItemCommand>
   </PropertyGroup>
   <PropertyGroup Condition="'$(AGENT_OS)' != 'Windows_NT'">
     <Python>$HELIX_PYTHONPATH</Python>
@@ -73,7 +76,7 @@
     <OutputMchPath>$HELIX_WORKITEM_UPLOAD_ROOT</OutputMchPath>
     <!-- Workaround until https://github.com/dotnet/arcade/pull/6179 is not available -->
     <HelixResultsDestinationDir>$(BUILD_SOURCESDIRECTORY)/artifacts/helixresults</HelixResultsDestinationDir>
-    <WorkItemCommand>$(SuperPMIDirectory)/superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)/pmi.dll -pmi_path @(PmiPathDirectories->'%(FullPath)', ' ')</WorkItemCommand>
+    <WorkItemCommand>$(SuperPMIDirectory)/superpmi.py collect -log_level DEBUG --$(CollectionType) -pmi_location $(SuperPMIDirectory)/pmi.dll -pmi_path @(PmiPathDirectories->'$(SuperPMIDirectory)/%(Identity)', ' ')</WorkItemCommand>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(WorkItemCommand)' != ''">

From 4bc40395f9f5d154f7ed2cb5e79bb1aaaa2fc917 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Wed, 26 Jan 2022 04:16:26 -0500
Subject: [PATCH 080/161] Disable RegexReductionTests on browser (#64312)

---
 .../tests/RegexReductionTests.cs                      | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
index f4fcbf92dadf1c..02c6e3a8f24456 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
@@ -6,7 +6,8 @@
 
 namespace System.Text.RegularExpressions.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/64300", TestPlatforms.Browser)]
+    [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Many of these optimizations don't exist in .NET Framework.")]
+    [SkipOnPlatform(TestPlatforms.Browser, "Internal members accessed via reflection may have been trimmed away")]
     public class RegexReductionTests
     {
         // These tests depend on using reflection to access internals of Regex in order to validate
@@ -25,9 +26,9 @@ public class RegexReductionTests
 
         static RegexReductionTests()
         {
-            if (PlatformDetection.IsNetFramework)
+            if (PlatformDetection.IsNetFramework || PlatformDetection.IsBrowser)
             {
-                // These members may not exist, and the tests won't run.
+                // These members may not exist or may have been trimmed away, and the tests won't run.
                 return;
             }
 
@@ -95,7 +96,6 @@ private static int GetMinRequiredLength(Regex r)
         }
 
         [Theory]
-        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Many of these optimizations don't exist in .NET Framework.")]
         // Two greedy one loops
         [InlineData("a*a*", "a*")]
         [InlineData("(a*a*)", "(a*)")]
@@ -475,7 +475,6 @@ public void PatternsReduceIdentically(string pattern1, string pattern2)
         }
 
         [Theory]
-        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Many of these optimizations don't exist in .NET Framework.")]
         // Not coalescing loops
         [InlineData("aa", "a{2}")]
         [InlineData("a[^a]", "a{2}")]
@@ -557,7 +556,6 @@ public void PatternsReduceDifferently(string pattern1, string pattern2)
         }
 
         [Theory]
-        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Not computed in netfx")]
         [InlineData(@"a", RegexOptions.None, 1, 1)]
         [InlineData(@"[^a]", RegexOptions.None, 1, 1)]
         [InlineData(@"[abcdefg]", RegexOptions.None, 1, 1)]
@@ -637,7 +635,6 @@ public void MinMaxLengthIsCorrect(string pattern, RegexOptions options, int expe
         }
 
         [Fact]
-        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Not computed in netfx")]
         public void MinMaxLengthIsCorrect_HugeDepth()
         {
             const int Depth = 10_000;

From d34c0ff7c104b3c6e39eb17cc0d21b7ca2dc5c6d Mon Sep 17 00:00:00 2001
From: Bar Arnon <i3arnon@gmail.com>
Date: Wed, 26 Jan 2022 11:58:21 +0200
Subject: [PATCH 081/161] Add UnreachableException (#63922)

---
 .../src/System/RuntimeType.CoreCLR.cs         |  2 +-
 .../BindingFlagSupport/ConstructorPolicies.cs |  2 +-
 .../Data/RestrictedTypeHandlingTests.cs       |  3 +-
 .../Formats/Asn1/AsnWriter.GeneralizedTime.cs |  7 +---
 .../src/System/Dynamic/Utils/ContractUtils.cs |  2 +-
 .../src/Resources/Strings.resx                |  3 ++
 .../System.Private.CoreLib.Shared.projitems   |  1 +
 .../Diagnostics/UnreachableException.cs       | 41 +++++++++++++++++++
 .../src/Resources/Strings.resx                |  3 --
 .../Internal/Utilities/ExceptionUtilities.cs  |  3 --
 .../tests/SerializationGuardTests.cs          |  2 +-
 .../System.Runtime/ref/System.Runtime.cs      |  6 +++
 .../Diagnostics/UnreachableExceptionTests.cs  | 40 ++++++++++++++++++
 src/mono/mono/tests/bug-gh-9507.cs            |  3 +-
 .../Interop/COM/ComWrappers/API/Program.cs    |  5 ++-
 .../ObjectiveCMarshalAPI/Program.cs           |  3 +-
 16 files changed, 105 insertions(+), 21 deletions(-)
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Diagnostics/UnreachableException.cs
 create mode 100644 src/libraries/System.Runtime/tests/System/Diagnostics/UnreachableExceptionTests.cs

diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
index a0d7026b544078..bf83df6c0f9751 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -1941,7 +1941,7 @@ private static PropertyInfo GetPropertyInfo(RuntimeType reflectedType, int tkPro
             }
 
             Debug.Fail("Unreachable code");
-            throw new SystemException();
+            throw new UnreachableException();
         }
 
         internal static void ValidateGenericArguments(MemberInfo definition, RuntimeType[] genericArguments, Exception? e)
diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/ConstructorPolicies.cs b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/ConstructorPolicies.cs
index 6b7b539996aec7..368105aa0de8a9 100644
--- a/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/ConstructorPolicies.cs
+++ b/src/coreclr/nativeaot/System.Private.Reflection.Core/src/System/Reflection/Runtime/BindingFlagSupport/ConstructorPolicies.cs
@@ -54,7 +54,7 @@ public sealed override bool OkToIgnoreAmbiguity(ConstructorInfo m1, ConstructorI
         {
             // Constructors are only resolvable using an array of parameter types so this should never be called.
             Debug.Fail("This code path should be unreachable.");
-            throw new NotSupportedException();
+            throw new UnreachableException();
         }
     }
 }
diff --git a/src/libraries/System.Data.Common/tests/System/Data/RestrictedTypeHandlingTests.cs b/src/libraries/System.Data.Common/tests/System/Data/RestrictedTypeHandlingTests.cs
index 54644b678a5bc2..d42609fed6b5cf 100644
--- a/src/libraries/System.Data.Common/tests/System/Data/RestrictedTypeHandlingTests.cs
+++ b/src/libraries/System.Data.Common/tests/System/Data/RestrictedTypeHandlingTests.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Data.SqlTypes;
+using System.Diagnostics;
 using System.Drawing;
 using System.IO;
 using System.Numerics;
@@ -433,7 +434,7 @@ public void ReadXml(XmlReader reader)
                 string tempPath = Path.GetTempFileName();
                 File.WriteAllText(tempPath, "This better not be written...");
                 File.Delete(tempPath);
-                throw new XunitException("Unreachable code (SerializationGuard should have kicked in)");
+                throw new UnreachableException("Unreachable code (SerializationGuard should have kicked in)");
             }
 
             public void WriteXml(XmlWriter writer)
diff --git a/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.GeneralizedTime.cs b/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.GeneralizedTime.cs
index 6b20ca15a3101d..7d8df542caf682 100644
--- a/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.GeneralizedTime.cs
+++ b/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.GeneralizedTime.cs
@@ -62,12 +62,7 @@ private void WriteGeneralizedTimeCore(
             // where "f?" is anything from "f" to "fffffff" (tenth of a second down to 100ns/1-tick)
             // with no trailing zeros.
             DateTimeOffset normalized = value.ToUniversalTime();
-
-            if (normalized.Year > 9999)
-            {
-                // This is unreachable since DateTimeOffset guards against this internally.
-                throw new ArgumentOutOfRangeException(nameof(value));
-            }
+            Debug.Assert(normalized.Year <= 9999, "DateTimeOffset guards against this internally");
 
             // We're only loading in sub-second ticks.
             // Ticks are defined as 1e-7 seconds, so their printed form
diff --git a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/ContractUtils.cs b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/ContractUtils.cs
index 8125fc9ac1159a..e481185ffa57a9 100644
--- a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/ContractUtils.cs
+++ b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/ContractUtils.cs
@@ -20,7 +20,7 @@ public static Exception Unreachable
             get
             {
                 Debug.Fail("Unreachable");
-                return new InvalidOperationException("Code supposed to be unreachable");
+                return new UnreachableException();
             }
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
index 8564b3894fa410..383660c6f9a920 100644
--- a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -786,6 +786,9 @@
   <data name="Arg_UnknownTypeCode" xml:space="preserve">
     <value>Unknown TypeCode value.</value>
   </data>
+  <data name="Arg_UnreachableException" xml:space="preserve">
+    <value>The program executed an instruction that was thought to be unreachable.</value>
+  </data>
   <data name="Arg_VarMissNull" xml:space="preserve">
     <value>Missing parameter does not have a default value.</value>
   </data>
diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index 8cf5cf0dda601b..b7079c0ea1ff52 100644
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -285,6 +285,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\StackTraceHiddenAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\Stopwatch.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\SymbolStore\ISymbolDocumentWriter.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\UnreachableException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\DivideByZeroException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\DllNotFoundException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Double.cs" />
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/UnreachableException.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/UnreachableException.cs
new file mode 100644
index 00000000000000..be8ff08940eebe
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/UnreachableException.cs
@@ -0,0 +1,41 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Diagnostics
+{
+    /// <summary>
+    /// Exception thrown when the program executes an instruction that was thought to be unreachable.
+    /// </summary>
+    public sealed class UnreachableException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="System.Diagnostics.UnreachableException"/> class with the default error message.
+        /// </summary>
+        public UnreachableException()
+            : base(SR.Arg_UnreachableException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="System.Diagnostics.UnreachableException"/>
+        /// class with a specified error message.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public UnreachableException(string? message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="System.Diagnostics.UnreachableException"/>
+        /// class with a specified error message and a reference to the inner exception that is the cause of
+        /// this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception.</param>
+        public UnreachableException(string? message, Exception? innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}
diff --git a/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx b/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx
index f4a6f030897903..e85eb5e2a3aa95 100644
--- a/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx
+++ b/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx
@@ -405,7 +405,4 @@
   <data name="UnexpectedValueUnknownType" xml:space="preserve">
     <value>Unexpected value '{0}' of unknown type.</value>
   </data>
-  <data name="UnreachableLocation" xml:space="preserve">
-    <value>This program location is thought to be unreachable.</value>
-  </data>
 </root>
diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Internal/Utilities/ExceptionUtilities.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Internal/Utilities/ExceptionUtilities.cs
index 3d6b4605cf492e..c0ebc31d376e83 100644
--- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Internal/Utilities/ExceptionUtilities.cs
+++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Internal/Utilities/ExceptionUtilities.cs
@@ -14,8 +14,5 @@ internal static Exception UnexpectedValue(object value)
 
             return new InvalidOperationException(SR.Format(SR.UnexpectedValueUnknownType, value));
         }
-
-        internal static Exception Unreachable =>
-            new InvalidOperationException(SR.UnreachableLocation);
     }
 }
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs
index 31329577fb6374..7c294ff0a6c1cd 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs
+++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs
@@ -91,7 +91,7 @@ private FileWriter(SerializationInfo info, StreamingContext context)
         {
             string tempPath = Path.GetTempFileName();
             File.WriteAllText(tempPath, "This better not be written...");
-            throw new InvalidOperationException("Unreachable code (SerializationGuard should have kicked in)");
+            throw new UnreachableException("Unreachable code (SerializationGuard should have kicked in)");
         }
 
         public void GetObjectData(SerializationInfo info, StreamingContext context)
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index 82211a2cca7c8d..35930e8deffa9f 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -9037,6 +9037,12 @@ public void Start() { }
         public static System.Diagnostics.Stopwatch StartNew() { throw null; }
         public void Stop() { }
     }
+    public sealed partial class UnreachableException : System.Exception
+    {
+        public UnreachableException() { }
+        public UnreachableException(string? message) { }
+        public UnreachableException(string? message, System.Exception? innerException) { }
+    }
 }
 namespace System.Diagnostics.CodeAnalysis
 {
diff --git a/src/libraries/System.Runtime/tests/System/Diagnostics/UnreachableExceptionTests.cs b/src/libraries/System.Runtime/tests/System/Diagnostics/UnreachableExceptionTests.cs
new file mode 100644
index 00000000000000..24fdc343966553
--- /dev/null
+++ b/src/libraries/System.Runtime/tests/System/Diagnostics/UnreachableExceptionTests.cs
@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+using Xunit;
+
+namespace System.Tests
+{
+    public static class UnreachableExceptionTests
+    {
+        [Fact]
+        public static void DefaultConstructor()
+        {
+            UnreachableException unreachableException = new UnreachableException();
+
+            Assert.NotNull(unreachableException.Message);
+        }
+
+        [Fact]
+        public static void MessageConstructor()
+        {
+            string message = "MessageConstructor";
+            UnreachableException unreachableException = new UnreachableException(message);
+
+            Assert.Equal(message, unreachableException.Message);
+        }
+
+        [Fact]
+        public static void MessageInnerExceptionConstructor()
+        {
+            string message = "MessageConstructor";
+            Exception innerException = new Exception();
+            UnreachableException unreachableException = new UnreachableException();
+
+            Assert.Equal(message, unreachableException.Message);
+            Assert.Same(innerException, unreachableException.InnerException);
+        }
+    }
+}
diff --git a/src/mono/mono/tests/bug-gh-9507.cs b/src/mono/mono/tests/bug-gh-9507.cs
index 9a6b60e85693fe..6291e1ca2e9af7 100644
--- a/src/mono/mono/tests/bug-gh-9507.cs
+++ b/src/mono/mono/tests/bug-gh-9507.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using type_with_special_array_cast = System.UInt64; // MonoClass<ulong[]>::cast_class = long
 using other_type = System.Double;
 
@@ -9,7 +10,7 @@ public TestIsInst() {
 		array = new T[16];
 
 		if (array is other_type[]) // should not crash or throw NullReferenceException
-			throw new System.Exception("Unreachable");
+			throw new System.UnreachableException();
 	}
 }
 
diff --git a/src/tests/Interop/COM/ComWrappers/API/Program.cs b/src/tests/Interop/COM/ComWrappers/API/Program.cs
index 99a2094c80b912..b5f6b4d09cfdce 100644
--- a/src/tests/Interop/COM/ComWrappers/API/Program.cs
+++ b/src/tests/Interop/COM/ComWrappers/API/Program.cs
@@ -6,6 +6,7 @@ namespace ComWrappersTests
     using System;
     using System.Collections;
     using System.Collections.Generic;
+    using System.Diagnostics;
     using System.Runtime.CompilerServices;
     using System.Runtime.InteropServices;
 
@@ -376,7 +377,7 @@ public enum FailureMode
                         throw new Exception() { HResult = ExceptionErrorCode };
                     default:
                         Assert.True(false, "Invalid failure mode");
-                        throw new Exception("UNREACHABLE");
+                        throw new UnreachableException();
                 }
             }
 
@@ -390,7 +391,7 @@ protected override object CreateObject(IntPtr externalComObject, CreateObjectFla
                         throw new Exception() { HResult = ExceptionErrorCode };
                     default:
                         Assert.True(false, "Invalid failure mode");
-                        throw new Exception("UNREACHABLE");
+                        throw new UnreachableException();
                 }
             }
 
diff --git a/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/Program.cs b/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/Program.cs
index b9d06dd5421624..f899919ef9dab6 100644
--- a/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/Program.cs
+++ b/src/tests/Interop/ObjectiveC/ObjectiveCMarshalAPI/Program.cs
@@ -5,6 +5,7 @@ namespace ObjectiveCMarshalAPI
 {
     using System;
     using System.Collections.Generic;
+    using System.Diagnostics;
     using System.Reflection;
     using System.Runtime.InteropServices;
     using System.Runtime.InteropServices.ObjectiveC;
@@ -269,7 +270,7 @@ public ExceptionException() {}
             }
 
             Assert.True(false, "Unknown exception type");
-            throw new Exception("Unreachable");
+            throw new UnreachableException();
         }
 
         class Scenario

From 2b1cf1e48c24c534d0e871e06c66e24fe0e8f568 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexander=20K=C3=B6plinger?= <alex.koeplinger@outlook.com>
Date: Wed, 26 Jan 2022 12:38:53 +0100
Subject: [PATCH 082/161] [mono] Recognize new names for Xamarin.iOS etc
 assemblies (#64278)

They are being renamed in https://github.com/xamarin/xamarin-macios/pull/13847
---
 src/mono/mono/mini/intrinsics.c        | 6 +++++-
 src/mono/mono/mini/mini-native-types.c | 8 ++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/mono/mono/mini/intrinsics.c b/src/mono/mono/mini/intrinsics.c
index 7dc808d2def83d..87ec858a46993e 100644
--- a/src/mono/mono/mini/intrinsics.c
+++ b/src/mono/mono/mini/intrinsics.c
@@ -1924,7 +1924,11 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign
 	} else if (((!strcmp (cmethod_klass_image->assembly->aname.name, "Xamarin.iOS") ||
 				 !strcmp (cmethod_klass_image->assembly->aname.name, "Xamarin.TVOS") ||
 				 !strcmp (cmethod_klass_image->assembly->aname.name, "Xamarin.MacCatalyst") ||
-				 !strcmp (cmethod_klass_image->assembly->aname.name, "Xamarin.Mac")) &&
+				 !strcmp (cmethod_klass_image->assembly->aname.name, "Xamarin.Mac") ||
+				 !strcmp (cmethod_klass_image->assembly->aname.name, "Microsoft.iOS") ||
+				 !strcmp (cmethod_klass_image->assembly->aname.name, "Microsoft.tvOS") ||
+				 !strcmp (cmethod_klass_image->assembly->aname.name, "Microsoft.MacCatalyst") ||
+				 !strcmp (cmethod_klass_image->assembly->aname.name, "Microsoft.macOS")) &&
 				!strcmp (cmethod_klass_name_space, "ObjCRuntime") &&
 				!strcmp (cmethod_klass_name, "Selector"))
 			   ) {
diff --git a/src/mono/mono/mini/mini-native-types.c b/src/mono/mono/mini/mini-native-types.c
index 9faebab38b2e99..a9a3a0f8e484bf 100644
--- a/src/mono/mono/mini/mini-native-types.c
+++ b/src/mono/mono/mini/mini-native-types.c
@@ -374,6 +374,14 @@ mono_class_is_magic_assembly (MonoClass *klass)
 		return TRUE;
 	if (!strcmp ("Xamarin.MacCatalyst", aname))
 		return TRUE;
+	if (!strcmp ("Microsoft.iOS", aname))
+		return TRUE;
+	if (!strcmp ("Microsoft.macOS", aname))
+		return TRUE;
+	if (!strcmp ("Microsoft.watchOS", aname))
+		return TRUE;
+	if (!strcmp ("Microsoft.MacCatalyst", aname))
+		return TRUE;
 	/* regression test suite */
 	if (!strcmp ("builtin-types", aname))
 		return TRUE;

From 994d390c7cdc1f91b2b37235cf68605ead5d7c44 Mon Sep 17 00:00:00 2001
From: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date: Wed, 26 Jan 2022 14:56:21 +0200
Subject: [PATCH 083/161] Remove usage of codecvt from corerun (#64157)

* Remove usage of codecvt from corerun

* Update src/coreclr/hosts/corerun/corerun.cpp

Co-authored-by: Aaron Robinson <arobins@microsoft.com>

Co-authored-by: Aaron Robinson <arobins@microsoft.com>
---
 src/coreclr/hosts/corerun/corerun.cpp |  8 ++---
 src/coreclr/hosts/corerun/corerun.hpp | 48 +++++++++++++++------------
 src/coreclr/hosts/corerun/dotenv.cpp  | 23 +++----------
 3 files changed, 35 insertions(+), 44 deletions(-)

diff --git a/src/coreclr/hosts/corerun/corerun.cpp b/src/coreclr/hosts/corerun/corerun.cpp
index 345a18ef6bc624..67a43e28b20d15 100644
--- a/src/coreclr/hosts/corerun/corerun.cpp
+++ b/src/coreclr/hosts/corerun/corerun.cpp
@@ -291,9 +291,9 @@ static int run(const configuration& config)
     }
 
     // Construct CoreCLR properties.
-    pal::string_utf8_t tpa_list_utf8 = pal::convert_to_utf8(std::move(tpa_list));
-    pal::string_utf8_t app_path_utf8 = pal::convert_to_utf8(std::move(app_path));
-    pal::string_utf8_t native_search_dirs_utf8 = pal::convert_to_utf8(native_search_dirs.str());
+    pal::string_utf8_t tpa_list_utf8 = pal::convert_to_utf8(tpa_list.c_str());
+    pal::string_utf8_t app_path_utf8 = pal::convert_to_utf8(app_path.c_str());
+    pal::string_utf8_t native_search_dirs_utf8 = pal::convert_to_utf8(native_search_dirs.str().c_str());
 
     std::vector<pal::string_utf8_t> user_defined_keys_utf8;
     std::vector<pal::string_utf8_t> user_defined_values_utf8;
@@ -334,7 +334,7 @@ static int run(const configuration& config)
     int propertyCount = (int)propertyKeys.size();
 
     // Construct arguments
-    pal::string_utf8_t exe_path_utf8 = pal::convert_to_utf8(std::move(exe_path));
+    pal::string_utf8_t exe_path_utf8 = pal::convert_to_utf8(exe_path.c_str());
     std::vector<pal::string_utf8_t> argv_lifetime;
     pal::malloc_ptr<const char*> argv_utf8{ pal::convert_argv_to_utf8(config.entry_assembly_argc, config.entry_assembly_argv, argv_lifetime) };
     pal::string_utf8_t entry_assembly_utf8 = pal::convert_to_utf8(config.entry_assembly_fullpath.c_str());
diff --git a/src/coreclr/hosts/corerun/corerun.hpp b/src/coreclr/hosts/corerun/corerun.hpp
index 9781299c8049ef..14cb9ec6580e16 100644
--- a/src/coreclr/hosts/corerun/corerun.hpp
+++ b/src/coreclr/hosts/corerun/corerun.hpp
@@ -88,11 +88,28 @@ namespace pal
         assert(wrote < needed);
         return { buffer.get() };
     }
+    inline string_utf8_t getenvA(const char* var)
+    {
+        DWORD needed = ::GetEnvironmentVariableA(var, nullptr, 0);
+        if (needed == 0)
+            return {};
+
+        malloc_ptr<char> buffer{ (char*)::malloc(needed * sizeof(char)) };
+        assert(buffer != nullptr);
+        DWORD wrote = ::GetEnvironmentVariableA(var, buffer.get(), needed);
+        assert(wrote < needed);
+        return { buffer.get() };
+    }
     inline void setenv(const char_t* var, string_t value)
     {
         BOOL success = ::SetEnvironmentVariableW(var, value.c_str());
         assert(success);
     }
+    inline void setenvA(const char* var, string_utf8_t value)
+    {
+        BOOL success = ::SetEnvironmentVariableA(var, value.c_str());
+        assert(success);
+    }
     inline string_t get_exe_path()
     {
         char_t file_name[1024];
@@ -177,31 +194,17 @@ namespace pal
 
     inline string_utf8_t convert_to_utf8(const char_t* str)
     {
-        // Compute the needed buffer
-        int bytes_req = ::WideCharToMultiByte(
-            CP_UTF8, 0, // Conversion args
-            str, -1,    // Input string
-            nullptr, 0, // Null to request side
-            nullptr, nullptr);
+        int bytes_req = ::WideCharToMultiByte(CP_UTF8, 0, str, -1, nullptr, 0, nullptr, nullptr);
 
         malloc_ptr<char> buffer{ (char*)::malloc(bytes_req) };
         assert(buffer != nullptr);
 
-        int written = ::WideCharToMultiByte(
-            CP_UTF8, 0, // Conversion args
-            str, -1,    // Input string
-            buffer.get(), bytes_req,  // Output buffer
-            nullptr, nullptr);
+        int written = ::WideCharToMultiByte(CP_UTF8, 0, str, -1, buffer.get(), bytes_req, nullptr, nullptr);
         assert(bytes_req == written);
 
         return { buffer.get() };
     }
 
-    inline string_utf8_t convert_to_utf8(string_t&& str)
-    {
-        return convert_to_utf8(str.c_str());
-    }
-
     inline bool try_load_hostpolicy(pal::string_t mock_hostpolicy_value)
     {
         const char_t* hostpolicyName = W("hostpolicy.dll");
@@ -360,11 +363,19 @@ namespace pal
             return {};
         return { val };
     }
+    inline string_utf8_t getenvA(const char* var)
+    {
+        return getenv(var);
+    }
     inline void setenv(const char_t* var, string_t value)
     {
         int error = ::setenv(var, value.c_str(), /* overwrite */ 1);
         assert(error == 0);
     }
+    inline void setenvA(const char* var, string_utf8_t value)
+    {
+        setenv(var, value.c_str());
+    }
 
     inline string_t get_exe_path() { return minipal_getexepath(); }
 
@@ -567,11 +578,6 @@ namespace pal
         return { str };
     }
 
-    inline string_utf8_t convert_to_utf8(string_t&& str)
-    {
-        return std::move(str);
-    }
-
     inline bool try_load_hostpolicy(pal::string_t mock_hostpolicy_value)
     {
         if (!string_ends_with(mock_hostpolicy_value, pal::nativelib_ext))
diff --git a/src/coreclr/hosts/corerun/dotenv.cpp b/src/coreclr/hosts/corerun/dotenv.cpp
index 0e0e37c7919b0a..8792d63151f56a 100644
--- a/src/coreclr/hosts/corerun/dotenv.cpp
+++ b/src/coreclr/hosts/corerun/dotenv.cpp
@@ -7,22 +7,8 @@
 #include <sstream>
 #include <algorithm>
 
-#ifdef TARGET_WINDOWS
-#include <codecvt>
-#endif
-
 namespace
 {
-    pal::string_t convert_to_string_t(std::string str)
-    {
-#ifdef TARGET_WINDOWS
-        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-        return converter.from_bytes(str);
-#else
-        return str;
-#endif
-    }
-
     bool read_var_name(std::istream& file, std::string& var_name_out)
     {
         std::string var_name;
@@ -326,8 +312,7 @@ dotenv::dotenv(pal::string_t dotEnvFilePath, std::istream& contents)
                 {
                     return dot_env_entry->second;
                 }
-                pal::string_t env_var_name = convert_to_string_t(name);
-                return pal::convert_to_utf8(pal::getenv(env_var_name.c_str()));
+                return pal::getenvA(name.c_str());
             }, temp_value))
         {
             _environmentVariables = {};
@@ -341,9 +326,9 @@ void dotenv::load_into_current_process() const
 {
     for (std::pair<std::string, std::string> env_vars : _environmentVariables)
     {
-        pal::string_t name_string = convert_to_string_t(env_vars.first);
-        pal::string_t value_string = convert_to_string_t(env_vars.second);
-        pal::setenv(name_string.c_str(), std::move(value_string));
+        pal::string_utf8_t name_string = env_vars.first;
+        pal::string_utf8_t value_string = env_vars.second;
+        pal::setenvA(name_string.c_str(), std::move(value_string));
     }
 }
 

From 12da7826e7235d9ffde336b9c41123182069b7ac Mon Sep 17 00:00:00 2001
From: Tom Deseyn <tom.deseyn@gmail.com>
Date: Wed, 26 Jan 2022 14:29:28 +0100
Subject: [PATCH 084/161] Refactor FileStatus.Unix. (#62721)

* Refactor FileStatus.Unix.

- Moves InitiallyDirectory out of FileStatus into FileSystemInfo.
In FileSystemInfo it can be a readonly field making its usage clearer.
And FileStatus can then directly be used to implement some FileSystem methods
without allocating an intermediate FileInfo/DirectoryInfo.

- Treat not exists/exist as initialized states to avoid wrongly assuming
initialized means the file cache is valid, which isn't so when the file does
not exist.

- Use 0 for tracking uninitialized to make default(FileStatus) uninitialized.
---
 .../tests/Directory/SymbolicLinks.cs          |   6 +-
 .../tests/DirectoryInfo/SymbolicLinks.cs      |   6 +-
 .../IO/Enumeration/FileSystemEntry.Unix.cs    |  14 +-
 .../src/System/IO/FileStatus.SetTimes.OSX.cs  |  10 +-
 .../IO/FileStatus.SetTimes.OtherUnix.cs       |   8 +-
 .../src/System/IO/FileStatus.Unix.cs          | 218 ++++++++----------
 .../src/System/IO/FileSystem.Unix.cs          |  40 +---
 .../src/System/IO/FileSystemInfo.Unix.cs      |  20 +-
 .../src/System/IO/FileSystemInfo.cs           |   1 -
 9 files changed, 134 insertions(+), 189 deletions(-)

diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/SymbolicLinks.cs b/src/libraries/System.IO.FileSystem/tests/Directory/SymbolicLinks.cs
index 43106e3c2a6b79..1052ddfc22b9b9 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/SymbolicLinks.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/SymbolicLinks.cs
@@ -47,11 +47,7 @@ protected override void AssertLinkExists(FileSystemInfo link)
             }
             else
             {
-                // Unix implementation detail:
-                // When the directory target does not exist FileStatus.GetExists returns false because:
-                // - We check _exists (which whould be true because the link itself exists).
-                // - We check InitiallyDirectory, which is the initial expected object type (which would be true).
-                // - We check _directory (false because the target directory does not exist)
+                // Unix requires the target to be a directory that exists.
                 Assert.False(link.Exists);
             }
         }
diff --git a/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/SymbolicLinks.cs b/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/SymbolicLinks.cs
index 84658b6f275b96..254c00df401335 100644
--- a/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/SymbolicLinks.cs
+++ b/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/SymbolicLinks.cs
@@ -44,11 +44,7 @@ protected override void AssertLinkExists(FileSystemInfo link)
             }
             else
             {
-                // Unix implementation detail:
-                // When the directory target does not exist FileStatus.GetExists returns false because:
-                // - We check _exists (which whould be true because the link itself exists).
-                // - We check InitiallyDirectory, which is the initial expected object type (which would be true).
-                // - We check _directory (false because the target directory does not exist)
+                // Unix requires the target to be a directory that exists.
                 Assert.False(link.Exists);
             }
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEntry.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEntry.Unix.cs
index 89c38584eea320..3c7fb6504473ed 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEntry.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEntry.Unix.cs
@@ -11,6 +11,7 @@ namespace System.IO.Enumeration
     public unsafe ref partial struct FileSystemEntry
    {
         private Interop.Sys.DirectoryEntry _directoryEntry;
+        private bool _isDirectory;
         private FileStatus _status;
         private Span<char> _pathBuffer;
         private ReadOnlySpan<char> _fullPath;
@@ -32,8 +33,8 @@ internal static FileAttributes Initialize(
             entry._pathBuffer = pathBuffer;
             entry._fullPath = ReadOnlySpan<char>.Empty;
             entry._fileName = ReadOnlySpan<char>.Empty;
+            entry._isDirectory = false;
             entry._status.InvalidateCaches();
-            entry._status.InitiallyDirectory = false;
 
             bool isDirectory = directoryEntry.InodeType == Interop.Sys.NodeType.DT_DIR;
             bool isSymlink   = directoryEntry.InodeType == Interop.Sys.NodeType.DT_LNK;
@@ -41,15 +42,15 @@ internal static FileAttributes Initialize(
 
             if (isDirectory)
             {
-                entry._status.InitiallyDirectory = true;
+                entry._isDirectory = true;
             }
             else if (isSymlink)
             {
-                entry._status.InitiallyDirectory = entry._status.IsDirectory(entry.FullPath, continueOnError: true);
+                entry._isDirectory = entry._status.IsDirectory(entry.FullPath, continueOnError: true);
             }
             else if (isUnknown)
             {
-                entry._status.InitiallyDirectory = entry._status.IsDirectory(entry.FullPath, continueOnError: true);
+                entry._isDirectory = entry._status.IsDirectory(entry.FullPath, continueOnError: true);
                 if (entry._status.IsSymbolicLink(entry.FullPath, continueOnError: true))
                 {
                     entry._directoryEntry.InodeType = Interop.Sys.NodeType.DT_LNK;
@@ -145,16 +146,17 @@ public FileAttributes Attributes
         public DateTimeOffset CreationTimeUtc => _status.GetCreationTime(FullPath, continueOnError: true);
         public DateTimeOffset LastAccessTimeUtc => _status.GetLastAccessTime(FullPath, continueOnError: true);
         public DateTimeOffset LastWriteTimeUtc => _status.GetLastWriteTime(FullPath, continueOnError: true);
+
         public bool IsHidden => _status.IsFileSystemEntryHidden(FullPath, FileName);
         internal bool IsReadOnly => _status.IsReadOnly(FullPath, continueOnError: true);
 
-        public bool IsDirectory => _status.InitiallyDirectory;
+        public bool IsDirectory => _isDirectory;
         internal bool IsSymbolicLink => _directoryEntry.InodeType == Interop.Sys.NodeType.DT_LNK;
 
         public FileSystemInfo ToFileSystemInfo()
         {
             string fullPath = ToFullPath();
-            return FileSystemInfo.Create(fullPath, new string(FileName), ref _status);
+            return FileSystemInfo.Create(fullPath, new string(FileName), _isDirectory, ref _status);
         }
 
         /// <summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OSX.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OSX.cs
index 23c46bae4a0125..40a887e7210be8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OSX.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OSX.cs
@@ -7,7 +7,7 @@ namespace System.IO
 {
     internal partial struct FileStatus
     {
-        internal void SetCreationTime(string path, DateTimeOffset time)
+        internal void SetCreationTime(string path, DateTimeOffset time, bool asDirectory)
         {
             // Try to set the attribute on the file system entry using setattrlist,
             // if we get ENOTSUP then it means that "The volume does not support
@@ -27,11 +27,11 @@ internal void SetCreationTime(string path, DateTimeOffset time)
             }
             else if (error == Interop.Error.ENOTSUP)
             {
-                SetAccessOrWriteTimeCore(path, time, isAccessTime: false, checkCreationTime: false);
+                SetAccessOrWriteTimeCore(path, time, isAccessTime: false, checkCreationTime: false, asDirectory);
             }
             else
             {
-                Interop.CheckIo(error, path, InitiallyDirectory);
+                Interop.CheckIo(error, path, asDirectory);
             }
         }
 
@@ -54,7 +54,7 @@ private unsafe Interop.Error SetCreationTimeCore(string path, long seconds, long
             return error;
         }
 
-        private void SetAccessOrWriteTime(string path, DateTimeOffset time, bool isAccessTime) =>
-            SetAccessOrWriteTimeCore(path, time, isAccessTime, checkCreationTime: true);
+        private void SetAccessOrWriteTime(string path, DateTimeOffset time, bool isAccessTime, bool asDirectory) =>
+            SetAccessOrWriteTimeCore(path, time, isAccessTime, checkCreationTime: true, asDirectory);
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OtherUnix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OtherUnix.cs
index d9d9b1eeb7c920..85b01fde17d7c1 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OtherUnix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.SetTimes.OtherUnix.cs
@@ -7,11 +7,11 @@ namespace System.IO
 {
     internal partial struct FileStatus
     {
-        internal void SetCreationTime(string path, DateTimeOffset time) =>
-            SetLastWriteTime(path, time);
+        internal void SetCreationTime(string path, DateTimeOffset time, bool asDirectory) =>
+            SetLastWriteTime(path, time, asDirectory);
 
-        private void SetAccessOrWriteTime(string path, DateTimeOffset time, bool isAccessTime) =>
-            SetAccessOrWriteTimeCore(path, time, isAccessTime, checkCreationTime: false);
+        private void SetAccessOrWriteTime(string path, DateTimeOffset time, bool isAccessTime, bool asDirectory) =>
+            SetAccessOrWriteTimeCore(path, time, isAccessTime, checkCreationTime: false, asDirectory);
 
         // This is not used on these platforms, but is needed for source compat
         private Interop.Error SetCreationTimeCore(string path, long seconds, long nanoseconds) =>
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.Unix.cs
index 20961a8fbbc2e4..91e67d1b9f74c6 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileStatus.Unix.cs
@@ -10,44 +10,44 @@ internal partial struct FileStatus
     {
         private const int NanosecondsPerTick = 100;
 
-        // The last cached lstat information about the file
+        private const int InitializedExistsDir = -3;  // target is directory.
+        private const int InitializedExistsFile = -2; // target is file.
+        private const int InitializedNotExists = -1;  // entry does not exist.
+        private const int Uninitialized = 0;          // uninitialized, '0' to make default(FileStatus) uninitialized.
+
+        // Tracks the initialization state.
+        // < 0 : initialized succesfully. Value is InitializedNotExists, InitializedExistsFile or InitializedExistsDir.
+        //   0 : uninitialized.
+        // > 0 : initialized with error. Value is raw errno.
+        private int _state;
+
+        // The last cached lstat information about the file.
+        // Must only be used after calling EnsureCachesInitialized and checking EntryExists is true.
         private Interop.Sys.FileStatus _fileCache;
 
-        // -1: if the file cache isn't initialized - Refresh should always change this value
-        //  0: if the file cache was initialized with no errors
-        // Positive number: the error code returned by the lstat call
-        private int _initializedFileCache;
-
-        // We track intent of creation to know whether or not we want to (1) create a
-        // DirectoryInfo around this status struct or (2) actually are part of a DirectoryInfo.
-        // Set to true during initialization when the DirectoryEntry's INodeType describes a directory
-        internal bool InitiallyDirectory { get; set; }
-
-        // Is a directory as of the last refresh
-        // Its value can come from either the main path or the symbolic link path
-        private bool _isDirectory;
-
-        // Exists as of the last refresh
-        private bool _exists;
-
-        private bool IsFileCacheInitialized => _initializedFileCache == 0;
-
-        // Check if the main path (without following symlinks) has the hidden attribute set
-        // Ideally, use this if Refresh has been successfully called at least once.
-        // But since it is also used for soft retrieval during FileSystemEntry initialization,
-        // we return false early if the cache has not been initialized
-        internal bool HasHiddenFlag => IsFileCacheInitialized &&
-            (_fileCache.UserFlags & (uint)Interop.Sys.UserFlags.UF_HIDDEN) == (uint)Interop.Sys.UserFlags.UF_HIDDEN;
-
-        // Checks if the main path (without following symlinks) has the read-only attribute set
-        // Ideally, use this if Refresh has been successfully called at least once.
-        // But since it is also used for soft retrieval during FileSystemEntry initialization,
-        // we return false early if the cache has not been initialized
-        internal bool HasReadOnlyFlag
+        private bool EntryExists => _state <= InitializedExistsFile;
+
+        private bool IsDir => _state == InitializedExistsDir;
+
+        // Check if the main path (without following symlinks) has the hidden attribute set.
+        private bool HasHiddenFlag
         {
             get
             {
-                if (!IsFileCacheInitialized)
+                Debug.Assert(_state != Uninitialized); // Use this after EnsureCachesInitialized has been called.
+
+                return EntryExists && (_fileCache.UserFlags & (uint)Interop.Sys.UserFlags.UF_HIDDEN) == (uint)Interop.Sys.UserFlags.UF_HIDDEN;
+            }
+        }
+
+        // Checks if the main path (without following symlinks) has the read-only attribute set.
+        private bool HasReadOnlyFlag
+        {
+            get
+            {
+                Debug.Assert(_state != Uninitialized); // Use this after EnsureCachesInitialized has been called.
+
+                if (!EntryExists)
                 {
                     return false;
                 }
@@ -78,6 +78,7 @@ internal bool HasReadOnlyFlag
 
 #if !TARGET_BROWSER
         // HasReadOnlyFlag cache.
+        // Must only be used after calling EnsureCachesInitialized.
         private int _isReadOnlyCache;
 
         private bool IsModeReadOnlyCore()
@@ -123,20 +124,20 @@ private bool IsModeReadOnlyCore()
 #endif
 
         // Checks if the main path is a symbolic link
-        // Only call if Refresh has been successfully called at least once
         private bool HasSymbolicLinkFlag
         {
             get
             {
-                Debug.Assert(IsFileCacheInitialized);
-                return (_fileCache.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFLNK;
+                Debug.Assert(_state != Uninitialized); // Use this after EnsureCachesInitialized has been called.
+
+                return EntryExists && (_fileCache.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFLNK;
             }
         }
 
-        // Sets the cache initialization flags to -1, which means the caches are now uninitialized
+        // Sets the cache initialization flags to 0, which means the caches are now uninitialized
         internal void InvalidateCaches()
         {
-            _initializedFileCache = -1;
+            _state = Uninitialized;
         }
 
         internal bool IsReadOnly(ReadOnlySpan<char> path, bool continueOnError = false)
@@ -169,7 +170,7 @@ internal bool IsFileSystemEntryHidden(ReadOnlySpan<char> path, ReadOnlySpan<char
         internal bool IsDirectory(ReadOnlySpan<char> path, bool continueOnError = false)
         {
             EnsureCachesInitialized(path, continueOnError);
-            return _isDirectory;
+            return IsDir;
         }
 
         internal bool IsSymbolicLink(ReadOnlySpan<char> path, bool continueOnError = false)
@@ -182,7 +183,7 @@ internal FileAttributes GetAttributes(ReadOnlySpan<char> path, ReadOnlySpan<char
         {
             EnsureCachesInitialized(path, continueOnError);
 
-            if (!_exists)
+            if (!EntryExists)
                 return (FileAttributes)(-1);
 
             FileAttributes attributes = default;
@@ -193,7 +194,7 @@ internal FileAttributes GetAttributes(ReadOnlySpan<char> path, ReadOnlySpan<char
             if (HasSymbolicLinkFlag)
                 attributes |= FileAttributes.ReparsePoint;
 
-            if (_isDirectory) // Refresh caches this
+            if (IsDir) // Refresh caches this
                 attributes |= FileAttributes.Directory;
 
             if (IsNameHidden(fileName) || HasHiddenFlag)
@@ -202,7 +203,7 @@ internal FileAttributes GetAttributes(ReadOnlySpan<char> path, ReadOnlySpan<char
             return attributes != default ? attributes : FileAttributes.Normal;
         }
 
-        internal void SetAttributes(string path, FileAttributes attributes)
+        internal void SetAttributes(string path, FileAttributes attributes, bool asDirectory)
         {
             // Validate that only flags from the attribute are being provided.  This is an
             // approximation for the validation done by the Win32 function.
@@ -221,7 +222,7 @@ internal void SetAttributes(string path, FileAttributes attributes)
 
             EnsureCachesInitialized(path);
 
-            if (!_exists)
+            if (!EntryExists)
                 FileSystemInfo.ThrowNotFound(path);
 
             if (Interop.Sys.CanSetHiddenFlag)
@@ -229,12 +230,12 @@ internal void SetAttributes(string path, FileAttributes attributes)
                 if ((attributes & FileAttributes.Hidden) != 0 && (_fileCache.UserFlags & (uint)Interop.Sys.UserFlags.UF_HIDDEN) == 0)
                 {
                     // If Hidden flag is set and cached file status does not have the flag set then set it
-                    Interop.CheckIo(Interop.Sys.LChflags(path, (_fileCache.UserFlags | (uint)Interop.Sys.UserFlags.UF_HIDDEN)), path, InitiallyDirectory);
+                    Interop.CheckIo(Interop.Sys.LChflags(path, (_fileCache.UserFlags | (uint)Interop.Sys.UserFlags.UF_HIDDEN)), path, asDirectory);
                 }
                 else if (HasHiddenFlag)
                 {
                     // If Hidden flag is not set and cached file status does have the flag set then remove it
-                    Interop.CheckIo(Interop.Sys.LChflags(path, (_fileCache.UserFlags & ~(uint)Interop.Sys.UserFlags.UF_HIDDEN)), path, InitiallyDirectory);
+                    Interop.CheckIo(Interop.Sys.LChflags(path, (_fileCache.UserFlags & ~(uint)Interop.Sys.UserFlags.UF_HIDDEN)), path, asDirectory);
                 }
             }
 
@@ -255,22 +256,23 @@ internal void SetAttributes(string path, FileAttributes attributes)
             // Change the permissions on the file
             if (newMode != _fileCache.Mode)
             {
-                Interop.CheckIo(Interop.Sys.ChMod(path, newMode), path, InitiallyDirectory);
+                Interop.CheckIo(Interop.Sys.ChMod(path, newMode), path, asDirectory);
             }
 
-            _initializedFileCache = -1;
+            InvalidateCaches();
         }
 
-        internal bool GetExists(ReadOnlySpan<char> path)
+        internal bool GetExists(ReadOnlySpan<char> path, bool asDirectory)
         {
             EnsureCachesInitialized(path, continueOnError: true);
-            return _exists && InitiallyDirectory == _isDirectory;
+            return EntryExists && asDirectory == IsDir;
         }
 
         internal DateTimeOffset GetCreationTime(ReadOnlySpan<char> path, bool continueOnError = false)
         {
             EnsureCachesInitialized(path, continueOnError);
-            if (!_exists)
+
+            if (!EntryExists)
                 return new DateTimeOffset(DateTime.FromFileTimeUtc(0));
 
             if ((_fileCache.Flags & Interop.Sys.FileStatusFlags.HasBirthTime) != 0)
@@ -287,29 +289,35 @@ internal DateTimeOffset GetCreationTime(ReadOnlySpan<char> path, bool continueOn
         internal DateTimeOffset GetLastAccessTime(ReadOnlySpan<char> path, bool continueOnError = false)
         {
             EnsureCachesInitialized(path, continueOnError);
-            if (!_exists)
+
+            if (!EntryExists)
                 return new DateTimeOffset(DateTime.FromFileTimeUtc(0));
+
             return UnixTimeToDateTimeOffset(_fileCache.ATime, _fileCache.ATimeNsec);
         }
 
-        internal void SetLastAccessTime(string path, DateTimeOffset time) => SetAccessOrWriteTime(path, time, isAccessTime: true);
+        internal void SetLastAccessTime(string path, DateTimeOffset time, bool asDirectory)
+            => SetAccessOrWriteTime(path, time, isAccessTime: true, asDirectory);
 
         internal DateTimeOffset GetLastWriteTime(ReadOnlySpan<char> path, bool continueOnError = false)
         {
             EnsureCachesInitialized(path, continueOnError);
-            if (!_exists)
+
+            if (!EntryExists)
                 return new DateTimeOffset(DateTime.FromFileTimeUtc(0));
+
             return UnixTimeToDateTimeOffset(_fileCache.MTime, _fileCache.MTimeNsec);
         }
 
-        internal void SetLastWriteTime(string path, DateTimeOffset time) => SetAccessOrWriteTime(path, time, isAccessTime: false);
+        internal void SetLastWriteTime(string path, DateTimeOffset time, bool asDirectory)
+            => SetAccessOrWriteTime(path, time, isAccessTime: false, asDirectory);
 
         private DateTimeOffset UnixTimeToDateTimeOffset(long seconds, long nanoseconds)
         {
             return DateTimeOffset.FromUnixTimeSeconds(seconds).AddTicks(nanoseconds / NanosecondsPerTick);
         }
 
-        private unsafe void SetAccessOrWriteTimeCore(string path, DateTimeOffset time, bool isAccessTime, bool checkCreationTime)
+        private unsafe void SetAccessOrWriteTimeCore(string path, DateTimeOffset time, bool isAccessTime, bool checkCreationTime, bool asDirectory)
         {
             // This api is used to set creation time on non OSX platforms, and as a fallback for OSX platforms.
             // The reason why we use it to set 'creation time' is the below comment:
@@ -327,6 +335,9 @@ private unsafe void SetAccessOrWriteTimeCore(string path, DateTimeOffset time, b
             InvalidateCaches();
             EnsureCachesInitialized(path);
 
+            if (!EntryExists)
+                FileSystemInfo.ThrowNotFound(path);
+
             // we use utimes()/utimensat() to set the accessTime and writeTime
             Interop.Sys.TimeSpec* buf = stackalloc Interop.Sys.TimeSpec[2];
 
@@ -354,7 +365,7 @@ private unsafe void SetAccessOrWriteTimeCore(string path, DateTimeOffset time, b
                 buf[1].TvNsec = nanoseconds;
             }
 #endif
-            Interop.CheckIo(Interop.Sys.UTimensat(path, buf), path, InitiallyDirectory);
+            Interop.CheckIo(Interop.Sys.UTimensat(path, buf), path, asDirectory);
 
             // On OSX-like platforms, when the modification time is less than the creation time (including
             // when the modification time is already less than but access time is being set), the creation
@@ -374,7 +385,7 @@ private unsafe void SetAccessOrWriteTimeCore(string path, DateTimeOffset time, b
                 Interop.Error error = SetCreationTimeCore(path, _fileCache.BirthTime, _fileCache.BirthTimeNsec);
                 if (error != Interop.Error.SUCCESS && error != Interop.Error.ENOTSUP)
                 {
-                    Interop.CheckIo(error, path, InitiallyDirectory);
+                    Interop.CheckIo(error, path, asDirectory);
                 }
             }
         }
@@ -385,50 +396,53 @@ internal long GetLength(ReadOnlySpan<char> path, bool continueOnError = false)
             // On Unix, it returns the length of the path stored in the link.
 
             EnsureCachesInitialized(path, continueOnError);
-            return IsFileCacheInitialized ? _fileCache.Size : 0;
+            return EntryExists ? _fileCache.Size : 0;
         }
 
         // Tries to refresh the lstat cache (_fileCache).
         // This method should not throw. Instead, we store the results, and we will throw when the user attempts to access any of the properties when there was a failure
         internal void RefreshCaches(ReadOnlySpan<char> path)
         {
-            _isDirectory = false;
             path = Path.TrimEndingDirectorySeparator(path);
 
-            // Retrieve the file cache (lstat) to get the details on the object, without following symlinks.
-            // If it is a symlink, then subsequently get details on the target of the symlink.
-            // We only report failure if the initial lstat fails, as a broken symlink should still report info on exists, attributes, etc.
-            if (!TryRefreshFileCache(path))
+#if !TARGET_BROWSER
+            _isReadOnlyCache = -1;
+#endif
+
+            int rv = Interop.Sys.LStat(path, out _fileCache);
+            if (rv < 0)
             {
-                _exists = false;
-                return;
-            }
+                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
 
-            // Do an initial check in case the main path is pointing to a directory
-            _isDirectory = CacheHasDirectoryFlag(_fileCache);
+                if (errorInfo.Error == Interop.Error.ENOENT || // A component of the path does not exist, or path is an empty string
+                    errorInfo.Error == Interop.Error.ENOTDIR)  // A component of the path prefix of path is not a directory
+                {
+                    _state = InitializedNotExists;
+                }
+                else
+                {
+                    Debug.Assert(errorInfo.RawErrno > 0); // Expect a positive integer
+                    _state = errorInfo.RawErrno; // Initialized with error.
+                }
 
-            // We also need to check if the main path is a symbolic link,
-            // in which case, we retrieve the symbolic link's target data
-            if (!_isDirectory && HasSymbolicLinkFlag && Interop.Sys.Stat(path, out Interop.Sys.FileStatus target) == 0)
-            {
-                // and check again if the symlink path is a directory
-                _isDirectory = CacheHasDirectoryFlag(target);
+                return;
             }
 
-            _exists = true;
+            // Check if the main path is a directory, or a link to a directory.
+            int fileType = _fileCache.Mode & Interop.Sys.FileTypes.S_IFMT;
+            bool isDirectory = fileType == Interop.Sys.FileTypes.S_IFDIR ||
+                               (fileType == Interop.Sys.FileTypes.S_IFLNK
+                                && Interop.Sys.Stat(path, out Interop.Sys.FileStatus target) == 0
+                                && (target.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR);
 
-            // Checks if the specified cache has the directory attribute set
-            // Only call if Refresh has been successfully called at least once, and you're
-            // certain the passed-in cache was successfully retrieved
-            static bool CacheHasDirectoryFlag(Interop.Sys.FileStatus cache) =>
-                (cache.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR;
+            _state = isDirectory ? InitializedExistsDir : InitializedExistsFile;
         }
 
-        // Checks if the file cache is set to -1 and refreshes it's value.
+        // Checks if the file cache is uninitialized and refreshes it's value.
         // If it failed, and continueOnError is set to true, this method will throw.
         internal void EnsureCachesInitialized(ReadOnlySpan<char> path, bool continueOnError = false)
         {
-            if (_initializedFileCache == -1)
+            if (_state == Uninitialized)
             {
                 RefreshCaches(path);
             }
@@ -443,9 +457,9 @@ internal void EnsureCachesInitialized(ReadOnlySpan<char> path, bool continueOnEr
         private void ThrowOnCacheInitializationError(ReadOnlySpan<char> path)
         {
             // Lstat should always be initialized by Refresh
-            if (_initializedFileCache != 0)
+            int errno = _state;
+            if (errno > 0)
             {
-                int errno = _initializedFileCache;
                 InvalidateCaches();
                 throw Interop.GetExceptionForIoErrno(new Interop.ErrorInfo(errno), new string(path));
             }
@@ -457,41 +471,5 @@ private static long UnixTimeSecondsToNanoseconds(DateTimeOffset time, long secon
             const long TicksPerSecond = TicksPerMillisecond * 1000;
             return (time.UtcDateTime.Ticks - DateTimeOffset.UnixEpoch.Ticks - seconds * TicksPerSecond) * NanosecondsPerTick;
         }
-
-        private bool TryRefreshFileCache(ReadOnlySpan<char> path)
-        {
-#if !TARGET_BROWSER
-            _isReadOnlyCache = -1;
-#endif
-            return VerifyStatCall(Interop.Sys.LStat(path, out _fileCache), out _initializedFileCache);
-        }
-
-        // Receives the return value of a stat or lstat call.
-        // If the call is unsuccessful, sets the initialized parameter to a positive number representing the last error info.
-        // If the call is successful, sets the initialized parameter to zero.
-        // The method returns true if the initialized parameter is set to zero, false otherwise.
-        private bool VerifyStatCall(int returnValue, out int initialized)
-        {
-            initialized = 0;
-
-            // Both stat and lstat return -1 on error, 0 on success
-            if (returnValue < 0)
-            {
-                Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
-
-                // This should never set the error if the file can't be found.
-                // (see the Windows refresh passing returnErrorOnNotFound: false).
-                if (errorInfo.Error != Interop.Error.ENOENT && // A component of the path does not exist, or path is an empty string
-                    errorInfo.Error != Interop.Error.ENOTDIR)  // A component of the path prefix of path is not a directory
-                {
-                    // Expect a positive integer
-                    initialized = errorInfo.RawErrno;
-                    Debug.Assert(initialized > 0);
-                }
-                return false;
-            }
-
-            return true;
-        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Unix.cs
index 566d3686ce5e16..3cff6ccd16e2bc 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Unix.cs
@@ -554,51 +554,25 @@ public static FileAttributes GetAttributes(string fullPath)
         }
 
         public static void SetAttributes(string fullPath, FileAttributes attributes)
-        {
-            new FileInfo(fullPath, null).Attributes = attributes;
-        }
+            => default(FileStatus).SetAttributes(fullPath, attributes, asDirectory: false);
 
         public static DateTimeOffset GetCreationTime(string fullPath)
-        {
-            return new FileInfo(fullPath, null).CreationTimeUtc;
-        }
+            => default(FileStatus).GetCreationTime(fullPath).UtcDateTime;
 
         public static void SetCreationTime(string fullPath, DateTimeOffset time, bool asDirectory)
-        {
-            FileSystemInfo info = asDirectory ?
-                (FileSystemInfo)new DirectoryInfo(fullPath, null) :
-                (FileSystemInfo)new FileInfo(fullPath, null);
-
-            info.CreationTimeCore = time;
-        }
+            => default(FileStatus).SetCreationTime(fullPath, time, asDirectory);
 
         public static DateTimeOffset GetLastAccessTime(string fullPath)
-        {
-            return new FileInfo(fullPath, null).LastAccessTimeUtc;
-        }
+            => default(FileStatus).GetLastAccessTime(fullPath).UtcDateTime;
 
         public static void SetLastAccessTime(string fullPath, DateTimeOffset time, bool asDirectory)
-        {
-            FileSystemInfo info = asDirectory ?
-                (FileSystemInfo)new DirectoryInfo(fullPath, null) :
-                (FileSystemInfo)new FileInfo(fullPath, null);
-
-            info.LastAccessTimeCore = time;
-        }
+            => default(FileStatus).SetLastAccessTime(fullPath, time, asDirectory);
 
         public static DateTimeOffset GetLastWriteTime(string fullPath)
-        {
-            return new FileInfo(fullPath, null).LastWriteTimeUtc;
-        }
+            => default(FileStatus).GetLastWriteTime(fullPath).UtcDateTime;
 
         public static void SetLastWriteTime(string fullPath, DateTimeOffset time, bool asDirectory)
-        {
-            FileSystemInfo info = asDirectory ?
-                (FileSystemInfo)new DirectoryInfo(fullPath, null) :
-                (FileSystemInfo)new FileInfo(fullPath, null);
-
-            info.LastWriteTimeCore = time;
-        }
+            => default(FileStatus).SetLastWriteTime(fullPath, time, asDirectory);
 
         public static string[] GetLogicalDrives()
         {
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.Unix.cs
index d59c90f23104ff..f74e3c411dd6f8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.Unix.cs
@@ -7,18 +7,18 @@ namespace System.IO
 {
     public partial class FileSystemInfo
     {
+        private readonly bool _asDirectory;
         private FileStatus _fileStatus;
 
         protected FileSystemInfo()
         {
-            _fileStatus.InitiallyDirectory = this is DirectoryInfo;
-            _fileStatus.InvalidateCaches();
+            _asDirectory = this is DirectoryInfo;
         }
 
-        internal static FileSystemInfo Create(string fullPath, string fileName, ref FileStatus fileStatus)
+        internal static FileSystemInfo Create(string fullPath, string fileName, bool asDirectory, ref FileStatus fileStatus)
         {
-            FileSystemInfo info = fileStatus.InitiallyDirectory
-                ? (FileSystemInfo)new DirectoryInfo(fullPath, fileName: fileName, isNormalized: true)
+            FileSystemInfo info = asDirectory
+                ? new DirectoryInfo(fullPath, fileName: fileName, isNormalized: true)
                 : new FileInfo(fullPath, fileName: fileName, isNormalized: true);
 
             Debug.Assert(!PathInternal.IsPartiallyQualified(fullPath), $"'{fullPath}' should be fully qualified when constructed from directory enumeration");
@@ -38,27 +38,27 @@ internal unsafe void Init(ref FileStatus fileStatus)
         public FileAttributes Attributes
         {
             get => _fileStatus.GetAttributes(FullPath, Name);
-            set => _fileStatus.SetAttributes(FullPath, value);
+            set => _fileStatus.SetAttributes(FullPath, value, _asDirectory);
         }
 
-        internal bool ExistsCore => _fileStatus.GetExists(FullPath);
+        internal bool ExistsCore => _fileStatus.GetExists(FullPath, _asDirectory);
 
         internal DateTimeOffset CreationTimeCore
         {
             get => _fileStatus.GetCreationTime(FullPath);
-            set => _fileStatus.SetCreationTime(FullPath, value);
+            set => _fileStatus.SetCreationTime(FullPath, value, _asDirectory);
         }
 
         internal DateTimeOffset LastAccessTimeCore
         {
             get => _fileStatus.GetLastAccessTime(FullPath);
-            set => _fileStatus.SetLastAccessTime(FullPath, value);
+            set => _fileStatus.SetLastAccessTime(FullPath, value, _asDirectory);
         }
 
         internal DateTimeOffset LastWriteTimeCore
         {
             get => _fileStatus.GetLastWriteTime(FullPath);
-            set => _fileStatus.SetLastWriteTime(FullPath, value);
+            set => _fileStatus.SetLastWriteTime(FullPath, value, _asDirectory);
         }
 
         internal long LengthCore => _fileStatus.GetLength(FullPath);
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.cs
index eb4111efee2b27..26a06b20986f84 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystemInfo.cs
@@ -87,7 +87,6 @@ public DateTime CreationTimeUtc
             set => CreationTimeCore = File.GetUtcDateTimeOffset(value);
         }
 
-
         public DateTime LastAccessTime
         {
             get => LastAccessTimeUtc.ToLocalTime();

From dd59ab044b0aaf7f7a81f4dba92c244825874fee Mon Sep 17 00:00:00 2001
From: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date: Wed, 26 Jan 2022 17:30:05 +0300
Subject: [PATCH 085/161] Fix unique VNs for `ADDR`s (#64230)

* Add the test

* Fix unique VNs for ADDRs

They need to keep the exception sets.
---
 src/coreclr/jit/valuenum.cpp                  | 20 ++++++-----
 .../JitBlue/Runtime_64208/Runtime_64208.cs    | 33 +++++++++++++++++++
 .../Runtime_64208/Runtime_64208.csproj        | 17 ++++++++++
 3 files changed, 62 insertions(+), 8 deletions(-)
 create mode 100644 src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.cs
 create mode 100644 src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.csproj

diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp
index 3faa6efc7ace9b..947f774fbdac05 100644
--- a/src/coreclr/jit/valuenum.cpp
+++ b/src/coreclr/jit/valuenum.cpp
@@ -8755,38 +8755,42 @@ void Compiler::fgValueNumberTree(GenTree* tree)
                 // Usually the ADDR and IND just cancel out...
                 // except when this GT_ADDR has a valid zero-offset field sequence
                 //
+
+                ValueNumPair  addrVNP            = ValueNumPair();
                 FieldSeqNode* zeroOffsetFieldSeq = nullptr;
                 if (GetZeroOffsetFieldMap()->Lookup(tree, &zeroOffsetFieldSeq) &&
                     (zeroOffsetFieldSeq != FieldSeqStore::NotAField()))
                 {
-                    ValueNum addrExtended = vnStore->ExtendPtrVN(arg->AsOp()->gtOp1, zeroOffsetFieldSeq);
+                    ValueNum addrExtended = vnStore->ExtendPtrVN(arg->AsIndir()->Addr(), zeroOffsetFieldSeq);
                     if (addrExtended != ValueNumStore::NoVN)
                     {
-                        tree->gtVNPair.SetBoth(addrExtended); // We don't care about lib/cons differences for addresses.
+                        // We don't care about lib/cons differences for addresses.
+                        addrVNP.SetBoth(addrExtended);
                     }
                     else
                     {
-                        // ExtendPtrVN returned a failure result
-                        // So give this address a new unique value
-                        tree->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, TYP_BYREF));
+                        // ExtendPtrVN returned a failure result - give this address a new unique value.
+                        addrVNP.SetBoth(vnStore->VNForExpr(compCurBB, TYP_BYREF));
                     }
                 }
                 else
                 {
                     // They just cancel, so fetch the ValueNumber from the op1 of the GT_IND node.
                     //
-                    GenTree* addr  = arg->AsIndir()->Addr();
-                    tree->gtVNPair = addr->gtVNPair;
+                    GenTree* addr = arg->AsIndir()->Addr();
+                    addrVNP       = addr->gtVNPair;
 
                     // For the CSE phase mark the address as GTF_DONT_CSE
                     // because it will end up with the same value number as tree (the GT_ADDR).
                     addr->gtFlags |= GTF_DONT_CSE;
                 }
+
+                tree->gtVNPair = vnStore->VNPWithExc(addrVNP, vnStore->VNPExceptionSet(arg->gtVNPair));
             }
             else
             {
                 // May be more cases to do here!  But we'll punt for now.
-                tree->gtVNPair.SetBoth(vnStore->VNForExpr(compCurBB, TYP_BYREF));
+                tree->gtVNPair = vnStore->VNPUniqueWithExc(TYP_BYREF, vnStore->VNPExceptionSet(arg->gtVNPair));
             }
         }
         else if ((oper == GT_IND) || GenTree::OperIsBlk(oper))
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.cs b/src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.cs
new file mode 100644
index 00000000000000..725475cc4a7184
--- /dev/null
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+public class Runtime_64208
+{
+    public static int Main(string[] args)
+    {
+        if (Method0() != null)
+        {
+            return 101;
+        }
+
+        return 100;
+    }
+
+    public struct S1
+    {
+        public string string_0;
+    }
+
+    static S1 s_s1_32 = new S1();
+
+    public static S1 LeafMethod15() => s_s1_32;
+
+    public static string Method0()
+    {
+        return LeafMethod15().string_0;
+    }
+}
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.csproj b/src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.csproj
new file mode 100644
index 00000000000000..00fe72ae9b9cdb
--- /dev/null
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_64208/Runtime_64208.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <Optimize>True</Optimize>
+    <CLRTestBatchPreCommands><![CDATA[
+      $(CLRTestBatchPreCommands)
+      set DOTNET_JitAggressiveInlining=1
+      ]]></CLRTestBatchPreCommands>
+    <BashCLRTestPreCommands><![CDATA[
+      $(BashCLRTestPreCommands)
+      export DOTNET_JitAggressiveInlining=1
+      ]]></BashCLRTestPreCommands>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+</Project>
\ No newline at end of file

From 9152986a602034601dad25dfe8d60af12d86f6cd Mon Sep 17 00:00:00 2001
From: Ilona Tomkowicz <32700855+ilonatommy@users.noreply.github.com>
Date: Wed, 26 Jan 2022 16:36:58 +0100
Subject: [PATCH 086/161] Implemented hierarchy of attributes. (#64201)

* Implemented hierarchy of attributes.

* Shortened.

* Fixed overlooked test naming and simplified.

* Partial refactor.
---
 .../debugger/BrowserDebugProxy/DebugStore.cs  |  31 ++-
 .../debugger/BrowserDebugProxy/MonoProxy.cs   |   9 +-
 .../DebuggerTestSuite/BreakpointTests.cs      | 183 ++++++++----------
 .../debugger/DebuggerTestSuite/MiscTests.cs   |   2 +-
 .../DebuggerTestSuite/SteppingTests.cs        |  58 ++----
 .../tests/debugger-test/debugger-test.cs      |  97 +++++++---
 6 files changed, 200 insertions(+), 180 deletions(-)

diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs b/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs
index 88ad41efc21722..cf9eff051b886c 100644
--- a/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/DebugStore.cs
@@ -396,6 +396,7 @@ public MethodInfo(AssemblyInfo assembly, MethodDefinitionHandle methodDefHandle,
 
                     }
                 }
+                DebuggerAttrInfo.ClearInsignificantAttrFlags();
             }
             localScopes = pdbMetadataReader.GetLocalScopes(methodDefHandle);
         }
@@ -486,10 +487,34 @@ public VarInfo[] GetLiveVarsAt(int offset)
 
         public class DebuggerAttributesInfo
         {
-            public bool HasDebuggerHidden { get; internal set; }
-            public bool HasStepThrough { get; internal set; }
-            public bool HasNonUserCode { get; internal set; }
+            internal bool HasDebuggerHidden { get; set; }
+            internal bool HasStepThrough { get; set; }
+            internal bool HasNonUserCode { get; set; }
             public bool HasStepperBoundary { get; internal set; }
+
+            internal void ClearInsignificantAttrFlags()
+            {
+                // hierarchy: hidden > stepThrough > nonUserCode > boundary
+                if (HasDebuggerHidden)
+                    HasStepThrough = HasNonUserCode = HasStepperBoundary = false;
+                else if (HasStepThrough)
+                    HasNonUserCode = HasStepperBoundary = false;
+                else if (HasNonUserCode)
+                    HasStepperBoundary = false;
+            }
+
+            public bool DoAttributesAffectCallStack(bool justMyCodeEnabled)
+            {
+                return HasStepThrough ||
+                    HasDebuggerHidden ||
+                    HasStepperBoundary ||
+                    (HasNonUserCode && justMyCodeEnabled);
+            }
+
+            public bool ShouldStepOut(EventKind eventKind)
+            {
+                return HasDebuggerHidden || (HasStepperBoundary && eventKind == EventKind.Step);
+            }
         }
     }
 
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs b/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs
index 5fc72c491c3b58..aed459c2218c48 100644
--- a/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs
+++ b/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs
@@ -874,14 +874,9 @@ private async Task<bool> SendCallStack(SessionId sessionId, ExecutionContext con
                 if (shouldReturn)
                     return true;
 
-                if (j == 0 &&
-                    (method?.Info.DebuggerAttrInfo.HasStepThrough == true ||
-                    method?.Info.DebuggerAttrInfo.HasDebuggerHidden == true ||
-                    method?.Info.DebuggerAttrInfo.HasStepperBoundary == true ||
-                    (method?.Info.DebuggerAttrInfo.HasNonUserCode == true && JustMyCode)))
+                if (j == 0 && method?.Info.DebuggerAttrInfo.DoAttributesAffectCallStack(JustMyCode) == true)
                 {
-                    if (method.Info.DebuggerAttrInfo.HasDebuggerHidden ||
-                        (method.Info.DebuggerAttrInfo.HasStepperBoundary && event_kind == EventKind.Step))
+                    if (method.Info.DebuggerAttrInfo.ShouldStepOut(event_kind))
                     {
                         if (event_kind == EventKind.Step)
                             context.IsSkippingHiddenMethod = true;
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs
index 3dc2bc246364c9..f5e6a5b9c2b93e 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs
@@ -667,45 +667,49 @@ await EvaluateAndCheck(
         }
 
 
-        [Fact]
-        public async Task DebuggerHiddenNoStopOnBp()
+        [Theory]
+        [InlineData("RunDebuggerHidden", "HiddenMethod")]
+        [InlineData("RunStepThroughWithHidden", "StepThroughWithHiddenBp")] // debuggerHidden shadows the effect of stepThrough
+        [InlineData("RunNonUserCodeWithHidden", "NonUserCodeWithHiddenBp")] // and nonUserCode
+        public async Task DebuggerHiddenNoStopOnBp(string evalFunName, string decoratedFunName)
         {
-            var bp_hidden = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "HiddenMethod", 1);
-            var bp_visible = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "VisibleMethod", 1);
+            var bp_hidden = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", decoratedFunName, 1);
+            var bp_final = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 2);
             Assert.Empty(bp_hidden.Value["locations"]);
             await EvaluateAndCheck(
-                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:Run'); }, 1);",
+                $"window.setTimeout(function() {{ invoke_static_method('[debugger-test] DebuggerAttribute:{evalFunName}'); }}, 1);",
                 "dotnet://debugger-test.dll/debugger-test.cs",
-                bp_visible.Value["locations"][0]["lineNumber"].Value<int>(),
-                bp_visible.Value["locations"][0]["columnNumber"].Value<int>(),
-                "VisibleMethod"
+                bp_final.Value["locations"][0]["lineNumber"].Value<int>(),
+                bp_final.Value["locations"][0]["columnNumber"].Value<int>(),
+                evalFunName
             );
         }
 
-        [Fact]
-        public async Task DebuggerHiddenStopOnUserBp()
+        [Theory]
+        [InlineData("RunDebuggerHidden")]
+        [InlineData("RunStepThroughWithHidden")] // debuggerHidden shadows the effect of stepThrough
+        [InlineData("RunNonUserCodeWithHidden")] // and nonUserCode
+        public async Task DebuggerHiddenStopOnUserBp(string evalFunName)
         {
-            var bp_init = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerBreak", 0);
+            var bp_init = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 2);
+            var bp_final = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 3);
             var init_location = await EvaluateAndCheck(
-                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerBreak'); }, 1);",
+                $"window.setTimeout(function() {{ invoke_static_method('[debugger-test] DebuggerAttribute:{evalFunName}'); }}, 2);",
                 "dotnet://debugger-test.dll/debugger-test.cs",
                 bp_init.Value["locations"][0]["lineNumber"].Value<int>(),
                 bp_init.Value["locations"][0]["columnNumber"].Value<int>(),
-                "RunDebuggerBreak"
+                evalFunName
             );
-            var pause_location = await SendCommandAndCheck(null, "Debugger.resume",
+            await SendCommandAndCheck(null, "Debugger.resume",
                 "dotnet://debugger-test.dll/debugger-test.cs",
-                bp_init.Value["locations"][0]["lineNumber"].Value<int>() + 1,
-                8,
-                "RunDebuggerBreak");
-            Assert.Equal(init_location["callFrames"][0]["functionName"], pause_location["callFrames"][0]["functionName"]);
-            var id = pause_location["callFrames"][0]["callFrameId"].Value<string>();
-            await EvaluateOnCallFrame(id, "local_var", false);
+                bp_init.Value["locations"][0]["lineNumber"].Value<int>(),
+                bp_init.Value["locations"][0]["columnNumber"].Value<int>(),
+                evalFunName);
             await SendCommandAndCheck(null, "Debugger.resume",
                 "dotnet://debugger-test.dll/debugger-test.cs",
-                835,
-                8,
-                "VisibleMethodDebuggerBreak");
+                bp_final.Value["locations"][0]["lineNumber"].Value<int>(),
+                bp_final.Value["locations"][0]["columnNumber"].Value<int>(),
+                evalFunName);
         }
     
         [Fact]
@@ -892,16 +896,15 @@ await StepAndCheck(StepKind.Over, "dotnet://ApplyUpdateReferencedAssembly.dll/Me
         }
         
         [Theory]
-        [InlineData(false, "RunStepThrough")]
-        [InlineData(true, "RunStepThrough")]
-        [InlineData(true, "RunNonUserCode")]
-        [InlineData(false, "RunNonUserCode")]
-        public async Task StepThroughOrNonUserCodeAttributeStepInNoBp(bool justMyCodeEnabled, string evalFunName)
+        [InlineData(false, "RunStepThrough", 847, 8)]
+        [InlineData(true, "RunStepThrough", 847, 8)]
+        [InlineData(false, "RunNonUserCode", 852, 4, "NonUserCodeBp")]
+        [InlineData(true, "RunNonUserCode", 867, 8)]
+        [InlineData(false, "RunStepThroughWithNonUserCode", 933, 8)]
+        [InlineData(true, "RunStepThroughWithNonUserCode", 933, 8)]
+        public async Task StepThroughOrNonUserCodeAttributeStepInNoBp(bool justMyCodeEnabled, string evalFunName, int line, int col, string funcName="")
         {
             var bp_init = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 1);
-            if (justMyCodeEnabled)
-                await SetJustMyCode(true);
-
             var init_location = await EvaluateAndCheck(
                 $"window.setTimeout(function() {{ invoke_static_method('[debugger-test] DebuggerAttribute:{evalFunName}'); }}, 1);",
                 "dotnet://debugger-test.dll/debugger-test.cs",
@@ -909,18 +912,22 @@ public async Task StepThroughOrNonUserCodeAttributeStepInNoBp(bool justMyCodeEna
                 bp_init.Value["locations"][0]["columnNumber"].Value<int>(),
                 evalFunName
             );
-            var (funcName, line, col) = (evalFunName, 868, 8);
-            if (evalFunName == "RunNonUserCode")
-                (funcName, line, col) = justMyCodeEnabled ? (evalFunName, 888, 8) : ("NonUserCodeBp", 873, 4);
+            await SetJustMyCode(justMyCodeEnabled);
+            if (funcName == "")
+                funcName = evalFunName;
             await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line, col, funcName);
         }
 
         [Theory]
-        [InlineData(false, "RunStepThrough", "StepThrougBp")]
-        [InlineData(true, "RunStepThrough", "StepThrougBp")]
-        [InlineData(true, "RunNonUserCode", "NonUserCodeBp")]
-        [InlineData(false, "RunNonUserCode", "NonUserCodeBp")]
-        public async Task StepThroughOrNonUserCodeAttributeStepInWithBp(bool justMyCodeEnabled, string evalFunName, string decoratedFunName)
+        [InlineData(false, "RunStepThrough", "StepThrougBp", "", 846, 8)]
+        [InlineData(true, "RunStepThrough", "StepThrougBp", "RunStepThrough", 847, 8)]
+        [InlineData(false, "RunNonUserCode", "NonUserCodeBp", "NonUserCodeBp", 852, 4)]
+        [InlineData(true, "RunNonUserCode", "NonUserCodeBp", "RunNonUserCode", 867, 8)]
+        [InlineData(false, "RunStepThroughWithNonUserCode", "StepThroughWithNonUserCodeBp", "", 932, 8)]
+        [InlineData(true, "RunStepThroughWithNonUserCode", "StepThroughWithNonUserCodeBp", "RunStepThroughWithNonUserCode", 933, 8)]
+        public async Task StepThroughOrNonUserCodeAttributeStepInWithBp(
+            bool justMyCodeEnabled, string evalFunName, string decoratedFunName,
+            string funName, int line, int col)
         {
             var bp_init = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 1);
             var init_location = await EvaluateAndCheck(
@@ -930,28 +937,19 @@ public async Task StepThroughOrNonUserCodeAttributeStepInWithBp(bool justMyCodeE
                 bp_init.Value["locations"][0]["columnNumber"].Value<int>(),
                 evalFunName
             );
-
-            if (justMyCodeEnabled)
-            {
-                await SetJustMyCode(true);
-                var line = (evalFunName == "RunNonUserCode") ? 888 : 868;
-                await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line, 8, evalFunName);
-            }
-            else
+            
+            await SetJustMyCode(justMyCodeEnabled);
+            if (!justMyCodeEnabled && funName == "")
             {
-                var (finalFunName, line3, col) = (decoratedFunName, 873, 4);
-                if (evalFunName == "RunStepThrough")
-                {
-                    var bp1_decorated_fun = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", decoratedFunName, 1);
-                    var bp2_decorated_fun = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", decoratedFunName, 3);
-                    (finalFunName, line3, col) = (evalFunName, 867, 8);
-                    var line1 = bp1_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>();
-                    var line2 = bp2_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>();
-                    await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line1, col, decoratedFunName);
-                    await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line2, col, decoratedFunName);
-                }
-                await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line3, col, finalFunName);
+                var bp1_decorated_fun = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", decoratedFunName, 1);
+                var bp2_decorated_fun = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", decoratedFunName, 3);
+                var line1 = bp1_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>();
+                var line2 = bp2_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>();
+                await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line1, 8, decoratedFunName);
+                await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line2, 8, decoratedFunName);
+                funName = evalFunName;
             }
+            await SendCommandAndCheck(null, "Debugger.stepInto", "dotnet://debugger-test.dll/debugger-test.cs", line, col, funName);
         }
 
         [Theory]
@@ -959,6 +957,8 @@ public async Task StepThroughOrNonUserCodeAttributeStepInWithBp(bool justMyCodeE
         [InlineData(true, "RunStepThrough", "StepThrougBp")]
         [InlineData(true, "RunNonUserCode", "NonUserCodeBp")]
         [InlineData(false, "RunNonUserCode", "NonUserCodeBp")]
+        [InlineData(false, "RunStepThroughWithNonUserCode", "StepThroughWithNonUserCodeBp")]
+        [InlineData(true, "RunStepThroughWithNonUserCode", "StepThroughWithNonUserCodeBp")]
         public async Task StepThroughOrNonUserCodeAttributeResumeWithBp(bool justMyCodeEnabled, string evalFunName, string decoratedFunName)
         {
             var bp_init = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 1);
@@ -970,9 +970,8 @@ public async Task StepThroughOrNonUserCodeAttributeResumeWithBp(bool justMyCodeE
                 evalFunName
             );
 
-            if (justMyCodeEnabled)
-                await SetJustMyCode(true);
-            else
+            await SetJustMyCode(justMyCodeEnabled);
+            if (!justMyCodeEnabled)
             {
                 var bp1_decorated_fun = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", decoratedFunName, 1);
                 var line1 = bp1_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>();
@@ -984,15 +983,22 @@ public async Task StepThroughOrNonUserCodeAttributeResumeWithBp(bool justMyCodeE
         }
 
         [Theory]
-        [InlineData(false, "Debugger.resume", "RunStepThrough", "StepThrougUserBp")]
-        [InlineData(false, "Debugger.stepInto", "RunStepThrough", "StepThrougUserBp")]
-        [InlineData(true, "Debugger.stepInto", "RunStepThrough", null)]
-        [InlineData(true, "Debugger.resume", "RunStepThrough", null)]
-        [InlineData(true, "Debugger.stepInto", "RunNonUserCode", null)]
-        [InlineData(true, "Debugger.resume", "RunNonUserCode", null)]
-        [InlineData(false, "Debugger.stepInto", "RunNonUserCode", "NonUserCodeUserBp")]
-        [InlineData(false, "Debugger.resume", "RunNonUserCode", "NonUserCodeUserBp")]
-        public async Task StepThroughOrNonUserCodAttributeWithUserBp(bool justMyCodeEnabled, string debuggingFunction, string evalFunName, string decoratedFunName)
+        [InlineData(false, "Debugger.stepInto", "RunStepThrough", "StepThrougUserBp", 841, 8, "RunStepThrough", 848, 4)]
+        [InlineData(true, "Debugger.stepInto", "RunStepThrough", "RunStepThrough", -1, 8, "RunStepThrough", -1, 4)]
+        [InlineData(false, "Debugger.resume", "RunStepThrough", "StepThrougUserBp", 841, 8, "RunStepThrough", 848, 4)]
+        [InlineData(true, "Debugger.resume", "RunStepThrough", "RunStepThrough", -1, 8, "RunStepThrough", -1, 4)]
+        [InlineData(false, "Debugger.stepInto", "RunNonUserCode",  "NonUserCodeUserBp", 860, 4, "NonUserCodeUserBp", 861, 8)]
+        [InlineData(true, "Debugger.stepInto", "RunNonUserCode", "RunNonUserCode", -1, 8, "RunNonUserCode", -1, 4)]
+        [InlineData(false, "Debugger.resume", "RunNonUserCode", "NonUserCodeUserBp", 861, 8, "RunNonUserCode", -1, 4)]
+        [InlineData(true, "Debugger.resume", "RunNonUserCode", "RunNonUserCode", -1, 8, "RunNonUserCode", -1, 4)]
+        [InlineData(false, "Debugger.stepInto", "RunStepThroughWithNonUserCode",  "StepThroughWithNonUserCodeUserBp", 927, 8, "RunStepThroughWithNonUserCode", 934, 4)]
+        [InlineData(true, "Debugger.stepInto", "RunStepThroughWithNonUserCode", "RunStepThroughWithNonUserCode", -1, 8, "RunStepThroughWithNonUserCode", -1, 4)]
+        [InlineData(false, "Debugger.resume", "RunStepThroughWithNonUserCode", "StepThroughWithNonUserCodeUserBp", 927, 8, "RunStepThroughWithNonUserCode", -1, 4)]
+        [InlineData(true, "Debugger.resume", "RunStepThroughWithNonUserCode", "RunStepThroughWithNonUserCode", -1, 8, "RunStepThroughWithNonUserCode", -1, 4)]
+        public async Task StepThroughOrNonUserCodeAttributeWithUserBp(
+            bool justMyCodeEnabled, string debuggingFunction, string evalFunName,
+            string functionNameCheck1, int line1, int col1, 
+            string functionNameCheck2, int line2, int col2)
         {
             var bp_init = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 2);
             var bp_outside_decorated_fun = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", evalFunName, 3);
@@ -1004,36 +1010,15 @@ public async Task StepThroughOrNonUserCodAttributeWithUserBp(bool justMyCodeEnab
                 bp_init.Value["locations"][0]["columnNumber"].Value<int>(),
                 evalFunName
             );
-            
-            int line1, line2;
-            var (col1, col2) = (8, 4); 
-            string function_name1, function_name2;
 
-            if (justMyCodeEnabled)
-            {
-                await SetJustMyCode(true); 
+            await SetJustMyCode(justMyCodeEnabled);
+            if (line1 == -1)
                 line1 = bp_outside_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>() - 1;
+            if (line2 == -1)
                 line2 = bp_outside_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>();
-                function_name1 = function_name2 = evalFunName;
-            }
-            else
-            {
-                if (debuggingFunction == "Debugger.stepInto" && evalFunName == "RunNonUserCode")
-                {
-                    (line1, col1) = (881, 4);
-                    (line2, col2) = (882, 8);
-                    function_name1 = function_name2 = decoratedFunName;
-                }
-                else
-                {
-                    line1 = evalFunName == "RunNonUserCode" ? 882 : 862;
-                    function_name1 = decoratedFunName;
-                    line2 = bp_outside_decorated_fun.Value["locations"][0]["lineNumber"].Value<int>();
-                    function_name2 = evalFunName;
-                }
-            }
-            await SendCommandAndCheck(null, debuggingFunction, "dotnet://debugger-test.dll/debugger-test.cs", line1, col1, function_name1);
-            await SendCommandAndCheck(null, debuggingFunction, "dotnet://debugger-test.dll/debugger-test.cs", line2, col2, function_name2);
+            
+            await SendCommandAndCheck(null, debuggingFunction, "dotnet://debugger-test.dll/debugger-test.cs", line1, col1, functionNameCheck1);
+            await SendCommandAndCheck(null, debuggingFunction, "dotnet://debugger-test.dll/debugger-test.cs", line2, col2, functionNameCheck2);
         }
 
         [Theory]
@@ -1064,7 +1049,7 @@ public async Task StepperBoundary(string debuggingAction, int lineBpInit, int li
                 await SendCommandAndCheck(null, debuggingAction, "dotnet://debugger-test.dll/debugger-test.cs", line_decorated_fun, col_decorated_fun, "BoundaryBp");
             }
             if (lineBpInit == 2)
-                await SendCommandAndCheck(null, debuggingAction, "dotnet://debugger-test.dll/debugger-test.cs", 900, 8, "BoundaryUserBp");
+                await SendCommandAndCheck(null, debuggingAction, "dotnet://debugger-test.dll/debugger-test.cs", 879, 8, "BoundaryUserBp");
             
             var line = bp_final.Value["locations"][0]["lineNumber"].Value<int>();
             var col = bp_final.Value["locations"][0]["columnNumber"].Value<int>();
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/MiscTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/MiscTests.cs
index 76f79a663f6e98..c19669bd0c88ec 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/MiscTests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/MiscTests.cs
@@ -913,7 +913,7 @@ public async Task InspectLocalsUsingClassFromLibraryUsingDebugTypeFull()
 
             await EvaluateAndCheck(
                 "window.setTimeout(function() {" + expression + "; }, 1);",
-                "dotnet://debugger-test.dll/debugger-test.cs", 924, 8,
+                "dotnet://debugger-test.dll/debugger-test.cs", 965, 8,
                 "CallToEvaluateLocal",
                 wait_for_event_fn: async (pause_location) =>
                 {
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/SteppingTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/SteppingTests.cs
index 3feb6695eed152..45f26a74c84a3a 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/SteppingTests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/SteppingTests.cs
@@ -959,75 +959,49 @@ await EvaluateAndCheck(
         }
 
         [Fact]
-        public async Task DebuggerAttributeIgnoreStepIntoDebuggerHidden()
+        public async Task DebuggerHiddenIgnoreStepInto()
         {
-            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "Run", 1);
+            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerHidden", 1);
             await EvaluateAndCheck(
-                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:Run'); }, 1);",
+                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerHidden'); }, 1);",
                 "dotnet://debugger-test.dll/debugger-test.cs",
                 pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
                 pause_location.Value["locations"][0]["columnNumber"].Value<int>(),
-                "Run"
+                "RunDebuggerHidden"
             );
             var step_into = await SendCommandAndCheck(null, $"Debugger.stepInto", null, -1, -1, null);
-
             Assert.Equal(
                 step_into["callFrames"][0]["location"]["lineNumber"].Value<int>(),
                 pause_location.Value["locations"][0]["lineNumber"].Value<int>() + 1
                 );
-
         }
 
-        [Fact]
-        public async Task DebuggerAttributeIgnoreStepIntoDebuggerHiddenWithDebuggerBreakCall()
+        [Theory]
+        [InlineData("Debugger.stepInto")]
+        [InlineData("Debugger.stepOver")]
+        public async Task DebuggerHiddenIgnoreStepUserBreakpoint(string steppingFunction)
         {
-            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerBreak", 1);
+            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerHidden", 1);
             await EvaluateAndCheck(
-                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerBreak'); }, 1);",
+                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerHidden'); }, 1);",
                 "dotnet://debugger-test.dll/debugger-test.cs",
                 pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
                 pause_location.Value["locations"][0]["columnNumber"].Value<int>(),
-                "RunDebuggerBreak"
+                "RunDebuggerHidden"
             );
-            var step_into1 = await SendCommandAndCheck(null, $"Debugger.stepInto", null, -1, -1, null);
-
+            // stepOver HiddenMethod:
+            var step_into1 = await SendCommandAndCheck(null, steppingFunction, null, -1, -1, null);
             Assert.Equal(
-                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>() + 1,
                 step_into1["callFrames"][0]["location"]["lineNumber"].Value<int>()
                 );
 
-            var step_into2 = await SendCommandAndCheck(null, $"Debugger.stepInto", null, -1, -1, null);
-
+            // freeze on HiddenMethodUserBreak:
+            var step_into2 = await SendCommandAndCheck(null, steppingFunction, null, -1, -1, null);
             Assert.Equal(
                 pause_location.Value["locations"][0]["lineNumber"].Value<int>() + 1,
                 step_into2["callFrames"][0]["location"]["lineNumber"].Value<int>()
                 );
-
-        }
-
-        [Fact]
-        public async Task DebuggerAttributeIgnoreStepOverDebuggerHiddenWithDebuggerBreakCall()
-        {
-            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerBreak", 1);
-            await EvaluateAndCheck(
-                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerBreak'); 1});",
-                "dotnet://debugger-test.dll/debugger-test.cs",
-                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
-                pause_location.Value["locations"][0]["columnNumber"].Value<int>(),
-                "RunDebuggerBreak"
-            );
-            var step_over1 = await SendCommandAndCheck(null, $"Debugger.stepOver", null, -1, -1, null);
-            Assert.Equal(
-                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
-                step_over1["callFrames"][0]["location"]["lineNumber"].Value<int>()
-                );
-
-            var step_over2 = await SendCommandAndCheck(null, $"Debugger.stepOver", null, -1, -1, null);
-
-            Assert.Equal(
-                pause_location.Value["locations"][0]["lineNumber"].Value<int>() + 1,
-                step_over2["callFrames"][0]["location"]["lineNumber"].Value<int>()
-                );
         }
     }
 }
diff --git a/src/mono/wasm/debugger/tests/debugger-test/debugger-test.cs b/src/mono/wasm/debugger/tests/debugger-test/debugger-test.cs
index 2c956cd31bbb6f..f2a97c20077275 100644
--- a/src/mono/wasm/debugger/tests/debugger-test/debugger-test.cs
+++ b/src/mono/wasm/debugger/tests/debugger-test/debugger-test.cs
@@ -810,50 +810,29 @@ public int Increment(int count)
 
 public class DebuggerAttribute
 {
-    static int currentCount = 0;
-
     [System.Diagnostics.DebuggerHidden]
     public static void HiddenMethod()
     {
-        currentCount++;
+        var a = 9;
     }
 
     [System.Diagnostics.DebuggerHidden]
-    public static void HiddenMethodDebuggerBreak()
-    {
-        var local_var = 12;
-        System.Diagnostics.Debugger.Break();
-        currentCount++;
-    }
-
-    public static void VisibleMethod()
-    {
-        currentCount++;
-    }
-
-    public static void VisibleMethodDebuggerBreak()
+    public static void HiddenMethodUserBreak()
     {
         System.Diagnostics.Debugger.Break();
-        currentCount++;
     }
 
-    public static void Run()
+    public static void RunDebuggerHidden()
     {
         HiddenMethod();
-        VisibleMethod();
-    }
-
-    public static void RunDebuggerBreak()
-    {
-        HiddenMethodDebuggerBreak();
-        VisibleMethodDebuggerBreak();
+        HiddenMethodUserBreak();
     }
     
     [System.Diagnostics.DebuggerStepThroughAttribute]
     public static void StepThrougBp()
     {
         var a = 0;
-        currentCount++;
+        a++;
         var b = 1;
     }
 
@@ -870,10 +849,10 @@ public static void RunStepThrough()
     }
 
     [System.Diagnostics.DebuggerNonUserCode]
-    public static void NonUserCodeBp(Action boundaryTestFun=null)
+    public static void NonUserCodeBp()
     {
         var a = 0;
-        currentCount++;
+        a++;
         var b = 1;
     }
 
@@ -912,6 +891,68 @@ public static void RunNoBoundary()
         NonUserCodeForBoundaryEscape(DebuggerAttribute.BoundaryBp);
         NonUserCodeForBoundaryEscape(DebuggerAttribute.BoundaryUserBp);
     }
+
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    [System.Diagnostics.DebuggerHidden]
+    public static void StepThroughWithHiddenBp()
+    {
+        var a = 9;
+    }
+
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    [System.Diagnostics.DebuggerHidden]
+    public static void StepThroughWithHiddenUserBp()
+    {
+        System.Diagnostics.Debugger.Break();
+    }
+
+    public static void RunStepThroughWithHidden()
+    {
+        StepThroughWithHiddenBp();
+        StepThroughWithHiddenUserBp();
+    }
+
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    [System.Diagnostics.DebuggerNonUserCode]
+    public static void StepThroughWithNonUserCodeBp()
+    {
+        var a = 0;
+        a++;
+        var b = 1;
+    }
+
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    [System.Diagnostics.DebuggerNonUserCode]
+    public static void StepThroughWithNonUserCodeUserBp()
+    {
+        System.Diagnostics.Debugger.Break();
+    }
+
+    public static void RunStepThroughWithNonUserCode()
+    {
+        StepThroughWithNonUserCodeBp();
+        StepThroughWithNonUserCodeUserBp();
+    }
+
+    [System.Diagnostics.DebuggerNonUserCode]
+    [System.Diagnostics.DebuggerHidden]
+    public static void NonUserCodeWithHiddenBp()
+    {
+        var a = 9;
+    }
+
+    [System.Diagnostics.DebuggerNonUserCode]
+    [System.Diagnostics.DebuggerHidden]
+    public static void NonUserCodeWithHiddenUserBp()
+    {
+        System.Diagnostics.Debugger.Break();
+    }
+
+    public static void RunNonUserCodeWithHidden()
+    {
+        NonUserCodeWithHiddenBp();
+        NonUserCodeWithHiddenUserBp();
+    }
 }
 
 public class DebugTypeFull

From ea3881b8423d18f7bb1185afde67f848d64d398e Mon Sep 17 00:00:00 2001
From: Jeremy Koritzinsky <jekoritz@microsoft.com>
Date: Wed, 26 Jan 2022 07:56:56 -0800
Subject: [PATCH 087/161] Update the managed type system to more gracefully
 fail when calling a varargs method. (#64286)

* Update the managed type system to more gracefully fail when calling a varargs method.

* Use ThrowHelper instead of manually throwing the exception.

* Update src/coreclr/tools/Common/TypeSystem/Ecma/EcmaSignatureParser.cs

Co-authored-by: Jan Kotas <jkotas@microsoft.com>
---
 .../tools/Common/TypeSystem/Ecma/EcmaSignatureParser.cs        | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaSignatureParser.cs b/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaSignatureParser.cs
index 48ca23cf1ea26f..537b494b0d6f9d 100644
--- a/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaSignatureParser.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaSignatureParser.cs
@@ -256,7 +256,8 @@ private TypeDesc ParseTypeImpl(SignatureTypeCode typeCode)
                     else
                         return null;
                 default:
-                    throw new BadImageFormatException();
+                    ThrowHelper.ThrowBadImageFormatException();
+                    return null;
             }
         }
 

From 26648d10e6427b819576a1839d6d3a04cfa4630e Mon Sep 17 00:00:00 2001
From: Zoltan Varga <vargaz@gmail.com>
Date: Wed, 26 Jan 2022 12:36:34 -0500
Subject: [PATCH 088/161] [mono] Add some missing
 Internal.Runtime.CompilerServices.Unsafe intrinsics. (#64314)

---
 src/mono/mono/mini/intrinsics.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/mono/mono/mini/intrinsics.c b/src/mono/mono/mini/intrinsics.c
index 87ec858a46993e..4f6a63b0480e4e 100644
--- a/src/mono/mono/mini/intrinsics.c
+++ b/src/mono/mono/mini/intrinsics.c
@@ -509,7 +509,7 @@ emit_unsafe_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignatu
 		g_assert (ctx->method_inst->type_argc == 1);
 		g_assert (fsig->param_count == 2);
 
-		if (fsig->params [1]->type == MONO_TYPE_I) {
+		if (fsig->params [1]->type == MONO_TYPE_I || fsig->params [1]->type == MONO_TYPE_U) {
 			int dreg = alloc_preg (cfg);
 			EMIT_NEW_BIALU (cfg, ins, OP_PADD, dreg, args [0]->dreg, args [1]->dreg);
 			ins->type = STACK_PTR;
@@ -583,6 +583,23 @@ emit_unsafe_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignatu
  		MONO_INST_NEW (cfg, ins, OP_NOP);
 		MONO_ADD_INS (cfg->cbb, ins);
 		return ins;
+	} else if (!strcmp (cmethod->name, "IsNullRef")) {
+		g_assert (fsig->param_count == 1);
+
+		MONO_EMIT_NEW_COMPARE_IMM (cfg, args [0]->dreg, 0);
+		int dreg = alloc_ireg (cfg);
+		EMIT_NEW_UNALU (cfg, ins, OP_PCEQ, dreg, -1);
+		return ins;
+	} else if (!strcmp (cmethod->name, "NullRef")) {
+		g_assert (ctx);
+		g_assert (ctx->method_inst);
+		g_assert (ctx->method_inst->type_argc == 1);
+		g_assert (fsig->param_count == 0);
+
+		EMIT_NEW_PCONST (cfg, ins, NULL);
+		ins->type = STACK_MP;
+		ins->klass = mono_class_from_mono_type_internal (fsig->ret);
+		return ins;
 	}
 
 	return NULL;

From d94ca5706c95b950719155905ec9a2d889160cbc Mon Sep 17 00:00:00 2001
From: Aaron Robinson <arobins@microsoft.com>
Date: Wed, 26 Jan 2022 13:20:12 -0500
Subject: [PATCH 089/161] Remove usage of FEATURE_CORESYSTEM (#63850)

* Remove usage of FEATURE_CORESYSTEM from coreclr.
---
 src/coreclr/clrdefinitions.cmake              |   1 -
 src/coreclr/debug/daccess/daccess.cpp         |  97 +-------
 src/coreclr/debug/daccess/dacimpl.h           |   8 -
 src/coreclr/debug/di/cordb.cpp                |  10 -
 src/coreclr/debug/di/module.cpp               |   4 +-
 src/coreclr/debug/di/nativepipeline.h         |  22 --
 src/coreclr/debug/di/process.cpp              |  67 +-----
 src/coreclr/debug/di/publish.cpp              |  93 +-------
 src/coreclr/debug/di/rsmain.cpp               |  28 +--
 src/coreclr/debug/di/rspriv.h                 |  15 --
 src/coreclr/debug/di/rsthread.cpp             |  16 --
 src/coreclr/debug/di/shimpriv.h               |   9 -
 src/coreclr/debug/di/shimprocess.cpp          | 225 ------------------
 src/coreclr/debug/di/windowspipeline.cpp      | 182 --------------
 src/coreclr/debug/ee/rcthread.cpp             |  29 +--
 src/coreclr/debug/inc/dbgipcevents.h          |  25 --
 .../debug/shared/dbgtransportsession.cpp      |   5 -
 src/coreclr/dlls/dbgshim/dbgshim.cpp          |  11 -
 src/coreclr/inc/bbsweep.h                     | 101 +-------
 src/coreclr/inc/clrconfigvalues.h             |   1 -
 src/coreclr/inc/clrtypes.h                    |   2 +-
 src/coreclr/inc/ostype.h                      |  32 ---
 src/coreclr/inc/switches.h                    |   2 -
 src/coreclr/inc/winwrap.h                     |  15 --
 .../nativeaot/Runtime/eventtracebase.h        |   7 -
 src/coreclr/utilcode/securitywrapper.cpp      | 123 ----------
 src/coreclr/utilcode/sstring.cpp              |   8 -
 src/coreclr/utilcode/util.cpp                 |  55 -----
 src/coreclr/utilcode/utilmessagebox.cpp       |  78 +++---
 src/coreclr/utilcode/winfix.cpp               |  33 ---
 src/coreclr/vm/.vscode/c_cpp_properties.json  |   1 -
 src/coreclr/vm/dwreport.cpp                   |  54 +----
 src/coreclr/vm/jithelpers.cpp                 |   8 -
 src/coreclr/vm/jitinterface.cpp               |   5 +-
 src/coreclr/vm/nativelibrary.cpp              |   4 +-
 src/coreclr/vm/util.cpp                       |  16 --
 src/coreclr/vm/win32threadpool.cpp            |   6 +-
 37 files changed, 72 insertions(+), 1326 deletions(-)

diff --git a/src/coreclr/clrdefinitions.cmake b/src/coreclr/clrdefinitions.cmake
index d5fc9f5e1ee8e5..533d5255002b49 100644
--- a/src/coreclr/clrdefinitions.cmake
+++ b/src/coreclr/clrdefinitions.cmake
@@ -92,7 +92,6 @@ endif(CLR_CMAKE_TARGET_WIN32)
 
 add_definitions(-DFEATURE_BASICFREEZE)
 add_definitions(-DFEATURE_CORECLR)
-add_definitions(-DFEATURE_CORESYSTEM)
 if(FEATURE_DBGIPC)
   add_definitions(-DFEATURE_DBGIPC_TRANSPORT_DI)
   add_definitions(-DFEATURE_DBGIPC_TRANSPORT_VM)
diff --git a/src/coreclr/debug/daccess/daccess.cpp b/src/coreclr/debug/daccess/daccess.cpp
index 9aaf6e6e4cb171..7936b3a1279a8c 100644
--- a/src/coreclr/debug/daccess/daccess.cpp
+++ b/src/coreclr/debug/daccess/daccess.cpp
@@ -6542,61 +6542,6 @@ bool ClrDataAccess::GetILImageInfoFromNgenPEFile(PEAssembly *pPEAssembly,
     return true;
 }
 
-#if defined(FEATURE_CORESYSTEM)
-/* static */
-// We extract "ni.dll from the NGEN image name to obtain the IL image name.
-// In the end we add given ilExtension.
-// This dependecy is based on Apollo installer behavior.
-bool ClrDataAccess::GetILImageNameFromNgenImage( LPCWSTR ilExtension,
-                                                 _Out_writes_(cchFilePath) LPWSTR wszFilePath,
-                                                 const DWORD cchFilePath)
-{
-    if (wszFilePath == NULL || cchFilePath == 0)
-    {
-        return false;
-    }
-
-    _wcslwr_s(wszFilePath, cchFilePath);
-    // Find the "ni.dll" extension.
-    // If none exists use NGEN image name.
-    //
-    const WCHAR* ngenExtension = W("ni.dll");
-
-    if (wcslen(ilExtension) <= wcslen(ngenExtension))
-    {
-        LPWSTR  wszFileExtension = wcsstr(wszFilePath, ngenExtension);
-        if (wszFileExtension != 0)
-        {
-            LPWSTR  wszNextFileExtension = wszFileExtension;
-            // Find last occurrence
-            do
-            {
-                wszFileExtension = wszNextFileExtension;
-                wszNextFileExtension = wcsstr(wszFileExtension + 1, ngenExtension);
-            } while (wszNextFileExtension != 0);
-
-            // Overwrite ni.dll with ilExtension
-            if (!memcpy_s(wszFileExtension,
-                            wcslen(ngenExtension)*sizeof(WCHAR),
-                            ilExtension,
-                            wcslen(ilExtension)*sizeof(WCHAR)))
-            {
-                wszFileExtension[wcslen(ilExtension)] = '\0';
-                return true;
-            }
-        }
-    }
-
-    //Use ngen filename if there is no ".ni"
-    if (wcsstr(wszFilePath, W(".ni")) == 0)
-    {
-        return true;
-    }
-
-    return false;
-}
-#endif // FEATURE_CORESYSTEM
-
 void *
 ClrDataAccess::GetMetaDataFromHost(PEAssembly* pPEAssembly,
                                    bool* isAlternate)
@@ -6705,7 +6650,6 @@ ClrDataAccess::GetMetaDataFromHost(PEAssembly* pPEAssembly,
             goto ErrExit;
         }
 
-#if defined(FEATURE_CORESYSTEM)
         const WCHAR* ilExtension = W("dll");
         WCHAR ngenImageName[MAX_LONGPATH] = {0};
         if (wcscpy_s(ngenImageName, ARRAY_SIZE(ngenImageName), uniPath) != 0)
@@ -6716,12 +6660,6 @@ ClrDataAccess::GetMetaDataFromHost(PEAssembly* pPEAssembly,
         {
             goto ErrExit;
         }
-        // Transform NGEN image name into IL Image name
-        if (!GetILImageNameFromNgenImage(ilExtension, uniPath, ARRAY_SIZE(uniPath)))
-        {
-            goto ErrExit;
-        }
-#endif//FEATURE_CORESYSTEM
 
         // RVA size in ngen image and IL image is the same. Because the only
         // different is in RVA. That is 4 bytes column fixed.
@@ -6943,11 +6881,6 @@ bool ClrDataAccess::TargetConsistencyAssertsEnabled()
     return m_fEnableTargetConsistencyAsserts;
 }
 
-#ifdef FEATURE_CORESYSTEM
-#define ctime_s _ctime32_s
-#define time_t __time32_t
-#endif
-
 //
 // VerifyDlls - Validate that the mscorwks in the target matches this version of mscordacwks
 // Only done on Windows and Mac builds at the moment.
@@ -7503,34 +7436,8 @@ BOOL OutOfProcessExceptionEventGetProcessIdAndThreadId(HANDLE hProcess, HANDLE h
     *pPId = (DWORD)(SIZE_T)hProcess;
     *pThreadId = (DWORD)(SIZE_T)hThread;
 #else
-#if !defined(FEATURE_CORESYSTEM)
-    HMODULE hKernel32 = WszGetModuleHandle(W("kernel32.dll"));
-#else
-	HMODULE hKernel32 = WszGetModuleHandle(W("api-ms-win-core-processthreads-l1-1-1.dll"));
-#endif
-    if (hKernel32 == NULL)
-    {
-        return FALSE;
-    }
-
-    typedef WINBASEAPI DWORD (WINAPI GET_PROCESSID_OF_THREAD)(HANDLE);
-    GET_PROCESSID_OF_THREAD * pGetProcessIdOfThread;
-
-    typedef WINBASEAPI DWORD (WINAPI GET_THREADID)(HANDLE);
-    GET_THREADID * pGetThreadId;
-
-    pGetProcessIdOfThread = (GET_PROCESSID_OF_THREAD *)GetProcAddress(hKernel32, "GetProcessIdOfThread");
-    pGetThreadId = (GET_THREADID *)GetProcAddress(hKernel32, "GetThreadId");
-
-    // OOP callbacks are used on Win7 or later.   We should have having below two APIs available.
-    _ASSERTE((pGetProcessIdOfThread != NULL) && (pGetThreadId != NULL));
-    if ((pGetProcessIdOfThread == NULL) || (pGetThreadId == NULL))
-    {
-        return FALSE;
-    }
-
-    *pPId = (*pGetProcessIdOfThread)(hThread);
-    *pThreadId = (*pGetThreadId)(hThread);
+    *pPId = GetProcessIdOfThread(hThread);
+    *pThreadId = GetThreadId(hThread);
 #endif // TARGET_UNIX
     return TRUE;
 }
diff --git a/src/coreclr/debug/daccess/dacimpl.h b/src/coreclr/debug/daccess/dacimpl.h
index 57a4dc1bbab8fc..318d88be4d0085 100644
--- a/src/coreclr/debug/daccess/dacimpl.h
+++ b/src/coreclr/debug/daccess/dacimpl.h
@@ -14,14 +14,11 @@
 #define __DACIMPL_H__
 
 #include "gcinterface.dac.h"
-
-#if defined(TARGET_ARM) || defined(FEATURE_CORESYSTEM) // @ARMTODO: STL breaks the build with current VC headers
 //---------------------------------------------------------------------------------------
 // Setting DAC_HASHTABLE tells the DAC to use the hand rolled hashtable for
 // storing code:DAC_INSTANCE .  Otherwise, the DAC uses the STL unordered_map to.
 
 #define DAC_HASHTABLE
-#endif // TARGET_ARM|| FEATURE_CORESYSTEM
 
 #ifndef DAC_HASHTABLE
 #pragma push_macro("return")
@@ -1520,11 +1517,6 @@ class ClrDataAccess
                                              DWORD &dwSize,
                                              _Out_writes_(cchPath) LPWSTR wszPath,
                                              const DWORD cchPath);
-#if defined(FEATURE_CORESYSTEM)
-    static bool GetILImageNameFromNgenImage(LPCWSTR ilExtension,
-                                            _Out_writes_(cchFilePath) LPWSTR wszFilePath,
-                                            const DWORD cchFilePath);
-#endif // FEATURE_CORESYSTEM
 };
 
 extern ClrDataAccess* g_dacImpl;
diff --git a/src/coreclr/debug/di/cordb.cpp b/src/coreclr/debug/di/cordb.cpp
index e195f3731a9e6f..2f014d1fa587c0 100644
--- a/src/coreclr/debug/di/cordb.cpp
+++ b/src/coreclr/debug/di/cordb.cpp
@@ -84,16 +84,6 @@
 //*****************************************************************************
 STDAPI CreateCordbObject(int iDebuggerVersion, IUnknown ** ppCordb)
 {
-#if !defined(FEATURE_DBGIPC_TRANSPORT_DI) && !defined(FEATURE_CORESYSTEM)
-    // This API should not be called for Windows CoreCLR unless we are doing interop-debugging
-    // (which is only supported internally).  Use code:CoreCLRCreateCordbObject instead.
-    if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_DbgEnableMixedModeDebugging) == 0)
-    {
-        _ASSERTE(!"Deprecated entry point CreateCordbObject() is called on Windows CoreCLR\n");
-        return E_NOTIMPL;
-    }
-#endif // !defined(FEATURE_DBGIPC_TRANSPORT_DI) && !defined(FEATURE_CORESYSTEM)
-
     if (ppCordb == NULL)
     {
         return E_INVALIDARG;
diff --git a/src/coreclr/debug/di/module.cpp b/src/coreclr/debug/di/module.cpp
index 6d6a7a55befa2e..e173671bc85137 100644
--- a/src/coreclr/debug/di/module.cpp
+++ b/src/coreclr/debug/di/module.cpp
@@ -5169,8 +5169,8 @@ HRESULT CordbNativeCode::GetReturnValueLiveOffsetImpl(Instantiation *currentInst
 
                 int skipBytes = 0;
 
-#if defined(TARGET_X86) && defined(FEATURE_CORESYSTEM)
-                // Skip nop sleds on x86 coresystem.  The JIT adds these instructions as a security measure,
+#if defined(PSEUDORANDOM_NOP_INSERTION)
+                // Skip nop sleds the JIT adds. These instructions as a security measure,
                 // and incorrectly reports to us the wrong offset of the call instruction.
                 const BYTE nop_opcode = 0x90;
                 while (fetched && nativeBuffer[0] == nop_opcode)
diff --git a/src/coreclr/debug/di/nativepipeline.h b/src/coreclr/debug/di/nativepipeline.h
index f1b973ea5967ca..fc03b277724744 100644
--- a/src/coreclr/debug/di/nativepipeline.h
+++ b/src/coreclr/debug/di/nativepipeline.h
@@ -146,28 +146,6 @@ class INativeEventPipeline
 
     virtual BOOL TerminateProcess(UINT32 exitCode) = 0;
 
-    //
-    // Resume any suspended threads in the currend process.
-    // This decreases the suspend count of each thread by at most 1.
-    // Call multiple times until it returns S_FALSE if you want to really ensure
-    // all threads are running.
-    //
-    // Notes:
-    //    On Windows the OS may suspend threads when continuing a 2nd-chance exception.
-    //    Call this to get them resumed again.  On other platforms this
-    //    will typically be a no-op, so I provide a default implementation to avoid
-    //    everyone having to override this.
-    //
-    // Return Value:
-    //    S_OK if at least one thread was resumed from a suspended state
-    //    S_FALSE if nothing was done
-    //    An error code indicating why we were not able to attempt this
-
-    virtual HRESULT EnsureThreadsRunning()
-    {
-        return S_FALSE;
-    }
-
 #ifdef TARGET_UNIX
     // Used by debugger side (RS) to cleanup the target (LS) named pipes
     // and semaphores when the debugger detects the debuggee process  exited.
diff --git a/src/coreclr/debug/di/process.cpp b/src/coreclr/debug/di/process.cpp
index 59af4cc8d9c649..26f1747d87a2c8 100644
--- a/src/coreclr/debug/di/process.cpp
+++ b/src/coreclr/debug/di/process.cpp
@@ -414,7 +414,6 @@ IMDInternalImport * CordbProcess::LookupMetaDataFromDebugger(
 
             WCHAR *mutableFilePath = (WCHAR *)filePath;
 
-#if defined(FEATURE_CORESYSTEM)
             size_t pathLen = wcslen(mutableFilePath);
 
             const WCHAR *nidll = W(".ni.dll");
@@ -429,7 +428,6 @@ IMDInternalImport * CordbProcess::LookupMetaDataFromDebugger(
             {
                 wcscpy_s(mutableFilePath+pathLen-dllLen, dllLen, W(".exe"));
             }
-#endif//FEATURE_CORESYSTEM
 
             ALLOW_DATATARGET_MISSING_MEMORY(
                 pMDII = LookupMetaDataFromDebuggerForSingleFile(pModule, mutableFilePath, dwImageTimeStamp, dwImageSize);
@@ -7626,27 +7624,7 @@ HRESULT CordbProcess::GetRuntimeOffsets()
 
 
     {
-#if !defined FEATURE_CORESYSTEM
-        // kernel32!OpenThread does not exist on all platforms (missing on Win98).
-        // So we need to delay load it.
-        typedef HANDLE (WINAPI *FPOPENTHREAD)(DWORD dwDesiredAccess,
-                                              BOOL bInheritHandle,
-                                              DWORD dwThreadId);
-
-
-
-        HMODULE mod = WszGetModuleHandle(W("kernel32.dll"));
-
-        _ASSERTE(mod != NULL); // can't fail since Kernel32.dll is already loaded.
-
-        const FPOPENTHREAD pfnOpenThread = (FPOPENTHREAD)GetProcAddress(mod, "OpenThread");
-
-        if (pfnOpenThread != NULL)
-        {
-            m_hHelperThread = pfnOpenThread(SYNCHRONIZE, FALSE, dwHelperTid);
-            CONSISTENCY_CHECK_MSGF(m_hHelperThread != NULL, ("Failed to get helper-thread handle. tid=0x%x\n", dwHelperTid));
-        }
-#elif TARGET_UNIX
+#if TARGET_UNIX
         m_hHelperThread = NULL; //RS is supposed to be able to live without a helper thread handle.
 #else
         m_hHelperThread = OpenThread(SYNCHRONIZE, FALSE, dwHelperTid);
@@ -7673,8 +7651,6 @@ HRESULT CordbProcess::GetRuntimeOffsets()
          m_runtimeOffsets.m_excepNotForRuntimeBPAddr));
     LOG((LF_CORDB, LL_INFO10000, "    m_notifyRSOfSyncCompleteBPAddr=   0x%p\n",
          m_runtimeOffsets.m_notifyRSOfSyncCompleteBPAddr));
-    LOG((LF_CORDB, LL_INFO10000, "    m_raiseException=                 0x%p\n",
-         m_runtimeOffsets.m_raiseExceptionAddr));
     LOG((LF_CORDB, LL_INFO10000, "    m_debuggerWordTLSIndex=           0x%08x\n",
          m_runtimeOffsets.m_debuggerWordTLSIndex));
 #endif // FEATURE_INTEROP_DEBUGGING
@@ -9819,27 +9795,22 @@ HRESULT CordbProcess::EnsureClrInstanceIdSet()
     // If we didn't expect a specific CLR, then attempt to attach to any.
     if (m_clrInstanceId == 0)
     {
-
-#ifdef FEATURE_CORESYSTEM
+        // The only case in which we were allowed to request the "default" CLR instance
+        // ID is when we're running in V2 mode.  In V3, the client is required to pass
+        // a non-zero value to OpenVirtualProcess. Since V2 is no longer supported we
+        // no longer attempt to find it.
         if(m_cordb->GetTargetCLR() != 0)
         {
             m_clrInstanceId = PTR_TO_CORDB_ADDRESS(m_cordb->GetTargetCLR());
             return S_OK;
         }
-#endif
 
-        // The only case in which we're allowed to request the "default" CLR instance
-        // ID is when we're running in V2 mode.  In V3, the client is required to pass
-        // a non-zero value to OpenVirtualProcess.
+        // In V3, the client is required to pass a non-zero value to OpenVirtualProcess.
+        // In V2 mode we should be setting target CLR up front but return an error
+        // if we haven't.
         _ASSERTE(m_pShim != NULL);
+        return E_UNEXPECTED;
 
-        HRESULT hr = m_pShim->FindLoadedCLR(&m_clrInstanceId);
-        if (FAILED(hr))
-        {
-            // Couldn't find a loaded clr - no CLR instance ID yet
-            _ASSERTE(m_clrInstanceId == 0);
-            return hr;
-        }
     }
 
     // We've (now) got a valid CLR instance id
@@ -14910,26 +14881,6 @@ HRESULT CordbProcess::IsReadyForDetach()
         pAppDomain = m_appDomains.FindNext(&foundAppDomain);
     }
 
-    // If we're using the shim, give a chance to early-out if the OS doesn't support detach
-    // so that the user can continue to debug in that case.
-    // Ideally we'd just rely on the failure from DebugActiveProcessStop, but by then it's too late
-    // to recover.  This function is our only chance to distinguish between graceful detach failures
-    // and hard detach failures (after which the process object is neutered).
-    if (m_pShim != NULL)
-    {
-#if !defined(FEATURE_CORESYSTEM) // CORESYSTEM TODO
-        HModuleHolder hKernel32;
-        hKernel32 = WszLoadLibrary(W("kernel32"));
-        if (hKernel32 == NULL)
-            return HRESULT_FROM_GetLastError();
-        typedef BOOL (*DebugActiveProcessStopSig) (DWORD);
-        DebugActiveProcessStopSig pDebugActiveProcessStop =
-            reinterpret_cast<DebugActiveProcessStopSig>(GetProcAddress(hKernel32, "DebugActiveProcessStop"));
-        if (pDebugActiveProcessStop == NULL)
-            return COR_E_PLATFORMNOTSUPPORTED;
-#endif
-    }
-
     return S_OK;
 }
 
diff --git a/src/coreclr/debug/di/publish.cpp b/src/coreclr/debug/di/publish.cpp
index 1d7741fb9ea75b..d27e28a4abc37c 100644
--- a/src/coreclr/debug/di/publish.cpp
+++ b/src/coreclr/debug/di/publish.cpp
@@ -43,54 +43,8 @@ BOOL GetAllProcessesInSystem(DWORD *ProcessId,
 {
     HandleHolder hSnapshotHolder;
 
-#if !defined(FEATURE_CORESYSTEM)
-    // Load the dll "kernel32.dll".
-    HModuleHolder hDll = WszLoadLibrary(W("kernel32"));
-    _ASSERTE(hDll != NULL);
-
-    if (hDll == NULL)
-    {
-        LOG((LF_CORDB, LL_INFO1000,
-                "Unable to load the dll for enumerating processes. "
-                "LoadLibrary (kernel32.dll) failed.\n"));
-        return FALSE;
-    }
-#else
-	// Load the dll "api-ms-win-obsolete-kernel32-l1-1-0.dll".
-    HModuleHolder hDll = WszLoadLibrary(W("api-ms-win-obsolete-kernel32-l1-1-0.dll"));
-    _ASSERTE(hDll != NULL);
-
-    if (hDll == NULL)
-    {
-        LOG((LF_CORDB, LL_INFO1000,
-                "Unable to load the dll for enumerating processes. "
-                "LoadLibrary (api-ms-win-obsolete-kernel32-l1-1-0.dll) failed.\n"));
-        return FALSE;
-    }
-#endif
-
-
     // Create the Process' Snapshot
-    // Get the pointer to the requested function
-    FARPROC pProcAddr = GetProcAddress(hDll, "CreateToolhelp32Snapshot");
-
-    // If the proc address was not found, return error
-    if (pProcAddr == NULL)
-    {
-        LOG((LF_CORDB, LL_INFO1000,
-                "Unable to enumerate processes in the system. "
-                "GetProcAddr (CreateToolhelp32Snapshot) failed.\n"));
-        return FALSE;
-    }
-
-
-
-    // Handle from CreateToolHelp32Snapshot must be freed via CloseHandle().
-    typedef HANDLE CREATETOOLHELP32SNAPSHOT(DWORD, DWORD);
-
-    HANDLE hSnapshot =
-            ((CREATETOOLHELP32SNAPSHOT *)pProcAddr)(TH32CS_SNAPPROCESS, NULL);
-
+    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
     if (hSnapshot == INVALID_HANDLE_VALUE)
     {
         LOG((LF_CORDB, LL_INFO1000,
@@ -101,29 +55,13 @@ BOOL GetAllProcessesInSystem(DWORD *ProcessId,
     // HandleHolder doesn't deal with INVALID_HANDLE_VALUE, so we only assign if we have a legal value.
     hSnapshotHolder.Assign(hSnapshot);
 
-    // Get the first process in the process list
-    // Get the pointer to the requested function
-    pProcAddr = GetProcAddress(hDll, "Process32First");
-
-    // If the proc address was not found, return error
-    if (pProcAddr == NULL)
-    {
-        LOG((LF_CORDB, LL_INFO1000,
-                "Unable to enumerate processes in the system. "
-                "GetProcAddr (Process32First) failed.\n"));
-        return FALSE;
-    }
-
     PROCESSENTRY32  PE32;
 
     // need to initialize the dwSize field before calling Process32First
     PE32.dwSize = sizeof (PROCESSENTRY32);
 
-    typedef BOOL PROCESS32FIRST(HANDLE, LPPROCESSENTRY32);
-
-    BOOL succ =
-            ((PROCESS32FIRST *)pProcAddr)(hSnapshot, &PE32);
-
+    // Get the first process in the process list
+    BOOL succ = Process32First(hSnapshot, &PE32);
     if (succ != TRUE)
     {
         LOG((LF_CORDB, LL_INFO1000,
@@ -132,29 +70,14 @@ BOOL GetAllProcessesInSystem(DWORD *ProcessId,
         return FALSE;
     }
 
-
     // Loop over and get all the remaining processes
-    // Get the pointer to the requested function
-    pProcAddr = GetProcAddress(hDll, "Process32Next");
-
-    // If the proc address was not found, return error
-    if (pProcAddr == NULL)
-    {
-        LOG((LF_CORDB, LL_INFO1000,
-                "Unable to enumerate processes in the system. "
-                "GetProcAddr (Process32Next) failed.\n"));
-        return FALSE;
-    }
-
-    typedef BOOL PROCESS32NEXT(HANDLE, LPPROCESSENTRY32);
-
     int iIndex = 0;
 
     do
     {
         ProcessId [iIndex++] = PE32.th32ProcessID;
 
-        succ = ((PROCESS32NEXT *)pProcAddr)(hSnapshot, &PE32);
+        succ = Process32Next(hSnapshot, &PE32);
 
     } while ((succ == TRUE) && (iIndex < (int)dwArraySize));
 
@@ -177,16 +100,12 @@ const DWORD SAFETY_TIMEOUT = 2000;
 // ******************************************
 
 CorpubPublish::CorpubPublish()
-    : CordbCommonBase(0),
-    m_fpGetModuleFileNameEx(NULL)
+    : CordbCommonBase(0)
+    , m_fpGetModuleFileNameEx(NULL)
 {
     // Try to get psapi!GetModuleFileNameExW once, and then every process object can use it.
     // If we can't get it, then we'll fallback to getting information from the IPC block.
-#if !defined(FEATURE_CORESYSTEM)
-    m_hPSAPIdll = WszLoadLibrary(W("psapi.dll"));
-#else
 	m_hPSAPIdll = WszLoadLibrary(W("api-ms-win-obsolete-psapi-l1-1-0.dll"));
-#endif
 
     if (m_hPSAPIdll != NULL)
     {
diff --git a/src/coreclr/debug/di/rsmain.cpp b/src/coreclr/debug/di/rsmain.cpp
index 5594b299e2d125..cc30e2c84136e3 100644
--- a/src/coreclr/debug/di/rsmain.cpp
+++ b/src/coreclr/debug/di/rsmain.cpp
@@ -961,15 +961,12 @@ Cordb::Cordb(CorDebugInterfaceVersion iDebuggerVersion)
 }
 
 Cordb::Cordb(CorDebugInterfaceVersion iDebuggerVersion, const ProcessDescriptor& pd)
-  : CordbBase(NULL, 0, enumCordb),
-    m_processes(11),
-    m_initialized(false),
-    m_debuggerSpecifiedVersion(iDebuggerVersion),
-    m_pd(pd)
-#ifdef FEATURE_CORESYSTEM
-    ,
-    m_targetCLR(0)
-#endif
+  : CordbBase(NULL, 0, enumCordb)
+  , m_processes(11)
+  , m_initialized(false)
+  , m_debuggerSpecifiedVersion(iDebuggerVersion)
+  , m_pd(pd)
+  , m_targetCLR(0)
 {
     g_pRSDebuggingInfo->m_Cordb = this;
 
@@ -1420,10 +1417,7 @@ HRESULT Cordb::SetTargetCLR(HMODULE hmodTargetCLR)
     if (m_initialized)
         return E_FAIL;
 
-#ifdef FEATURE_CORESYSTEM
     m_targetCLR = hmodTargetCLR;
-#endif
-
     return S_OK;
 }
 
@@ -1528,16 +1522,6 @@ bool Cordb::IsInteropDebuggingSupported()
     // We explicitly refrain from checking the unmanaged callback. See comment in
     // ICorDebug::SetUnmanagedHandler for details.
 #ifdef FEATURE_INTEROP_DEBUGGING
-
-#if !defined(FEATURE_CORESYSTEM)
-    // Interop debugging is only supported internally on CoreCLR.
-    // Check if the special reg key is set.  If not, then we don't allow interop debugging.
-    if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_DbgEnableMixedModeDebugging) == 0)
-    {
-        return false;
-    }
-#endif // FEATURE_CORESYSTEM
-
     return true;
 #else
     return false;
diff --git a/src/coreclr/debug/di/rspriv.h b/src/coreclr/debug/di/rspriv.h
index 690917c2795a91..bbb9dbd5d5253e 100644
--- a/src/coreclr/debug/di/rspriv.h
+++ b/src/coreclr/debug/di/rspriv.h
@@ -2324,9 +2324,7 @@ class Cordb : public CordbBase, public ICorDebug, public ICorDebugRemote
 
     CorDebugInterfaceVersion    GetDebuggerVersion() const;
 
-#ifdef FEATURE_CORESYSTEM
     HMODULE GetTargetCLR() { return m_targetCLR; }
-#endif
 
 private:
     bool IsCreateProcessSupported();
@@ -2347,11 +2345,7 @@ class Cordb : public CordbBase, public ICorDebug, public ICorDebugRemote
     // Store information about the process to be debugged
     ProcessDescriptor m_pd;
 
-//Note - this code could be useful outside coresystem, but keeping the change localized
-// because we are late in the win8 release
-#ifdef FEATURE_CORESYSTEM
     HMODULE m_targetCLR;
-#endif
 };
 
 
@@ -6266,10 +6260,6 @@ class CordbThread : public CordbBase, public ICorDebugThread,
    BOOL ConvertFrameForILMethodWithoutMetadata(ICorDebugFrame *           pFrame,
                                                ICorDebugInternalFrame2 ** ppInternalFrame2);
 
-    // Gets/sets m_fCreationEventQueued
-    bool CreateEventWasQueued();
-    void SetCreateEventQueued();
-
     //-----------------------------------------------------------
     // Data members
     //-----------------------------------------------------------
@@ -6327,11 +6317,6 @@ class CordbThread : public CordbBase, public ICorDebugThread,
     // Both events will set this bit high. Be careful not to reset this bit inbetween them.
     bool                  m_fException;
 
-    // True if a creation event has been queued for this thread
-    // The event may or may not have been dispatched yet
-    // Bugfix DevDiv2\DevDiv 77523 - this is only being set from ShimProcess::QueueFakeThreadAttachEventsNativeOrder
-    bool                  m_fCreationEventQueued;
-
     // Object handle for Exception object in debuggee.
     VMPTR_OBJECTHANDLE    m_vmExcepObjHandle;
 
diff --git a/src/coreclr/debug/di/rsthread.cpp b/src/coreclr/debug/di/rsthread.cpp
index 577574b796019c..75479f9540ecf6 100644
--- a/src/coreclr/debug/di/rsthread.cpp
+++ b/src/coreclr/debug/di/rsthread.cpp
@@ -81,7 +81,6 @@ CordbThread::CordbThread(CordbProcess * pProcess, VMPTR_Thread vmThread) :
     m_fFloatStateValid(false),
     m_floatStackTop(0),
     m_fException(false),
-    m_fCreationEventQueued(false),
     m_EnCRemapFunctionIP(NULL),
     m_userState(kInvalidUserState),
     m_hCachedThread(INVALID_HANDLE_VALUE),
@@ -2790,21 +2789,6 @@ HRESULT CordbThread::GetBlockingObjects(ICorDebugBlockingObjectEnum **ppBlocking
     return hr;
 }
 
-// ----------------------------------------------------------------------------
-// CordbThread::SetCreateEventQueued
-void CordbThread::SetCreateEventQueued()
-{
-    m_fCreationEventQueued = true;
-}
-
-// ----------------------------------------------------------------------------
-// CordbThread::CreateEventWasQueued
-bool CordbThread::CreateEventWasQueued()
-{
-    return m_fCreationEventQueued;
-}
-
-
 #ifdef FEATURE_INTEROP_DEBUGGING
 /* ------------------------------------------------------------------------- *
  * Unmanaged Thread classes
diff --git a/src/coreclr/debug/di/shimpriv.h b/src/coreclr/debug/di/shimpriv.h
index 26a939ee8a3a8e..15efec56473493 100644
--- a/src/coreclr/debug/di/shimpriv.h
+++ b/src/coreclr/debug/di/shimpriv.h
@@ -426,9 +426,6 @@ class ShimProcess
     // Helper to queue fake assembly and mdule events
     void QueueFakeAssemblyAndModuleEvent(ICorDebugAssembly * pAssembly);
 
-    // Queue fake thread-create events on attach. Order via native threads.
-    HRESULT QueueFakeThreadAttachEventsNativeOrder();
-
     // Queue fake thread-create events on attach. No ordering.
     HRESULT QueueFakeThreadAttachEventsNoOrder();
 
@@ -491,9 +488,6 @@ class ShimProcess
     // dispatching an event.
     void PreDispatchEvent(bool fRealCreateProcessEvent = false);
 
-    // Look for a CLR in the process and if found, return it's instance ID
-    HRESULT FindLoadedCLR(CORDB_ADDRESS * pClrInstanceId);
-
     // Retrieve the IP address and the port number of the debugger proxy.
     MachineInfo GetMachineInfo();
 
@@ -526,9 +520,6 @@ class ShimProcess
     HANDLE  m_markAttachPendingEvent;
     HANDLE  m_terminatingEvent;
 
-    // Finds the base address of [core]clr.dll
-    CORDB_ADDRESS GetCLRInstanceBaseAddress();
-
     //
     // Event Queues
     //
diff --git a/src/coreclr/debug/di/shimprocess.cpp b/src/coreclr/debug/di/shimprocess.cpp
index 72da6068e8235b..8d60f954b4a714 100644
--- a/src/coreclr/debug/di/shimprocess.cpp
+++ b/src/coreclr/debug/di/shimprocess.cpp
@@ -17,10 +17,6 @@
 #include <limits.h>
 #include "shimpriv.h"
 
-#if !defined(FEATURE_CORESYSTEM)
-#include <tlhelp32.h>
-#endif
-
 //---------------------------------------------------------------------------------------
 //
 // Ctor for a ShimProcess
@@ -871,8 +867,6 @@ HRESULT ShimProcess::HandleWin32DebugEvent(const DEBUG_EVENT * pEvent)
             if (!fSkipResume)
             {
                 ::Sleep(500);
-                hrIgnore = GetNativePipeline()->EnsureThreadsRunning();
-                SIMPLIFYING_ASSUMPTION_SUCCEEDED(hrIgnore);
             }
         }
     }
@@ -1020,9 +1014,6 @@ void ShimProcess::QueueFakeAttachEventsIfNeeded(bool fRealCreateProcessEvent)
 //    same order that V2 used. So without using platform-specific thread-enumeration,
 //    we can't get the V2 ordering.
 //
-//    Compare to code:ShimProcess::QueueFakeThreadAttachEventsNativeOrder,
-//    which sends threads in the OS native thread create order.
-//
 HRESULT ShimProcess::QueueFakeThreadAttachEventsNoOrder()
 {
     ICorDebugProcess * pProcess = GetProcess();
@@ -1061,136 +1052,6 @@ HRESULT ShimProcess::QueueFakeThreadAttachEventsNoOrder()
     return S_OK;
 }
 
-//---------------------------------------------------------------------------------------
-// Send fake Thread-create events for attach, using the order of the OS native
-// thread list.
-//
-// Returns:
-//    S_OK on success, else error.
-//
-// Notes:
-//    This sends fake thread-create events, ala V2 attach.
-//    See code:ShimProcess::QueueFakeAttachEvents for details
-//    The order of the thread creates matches the OS's native thread list.
-//    This is important because the debugger can use the order of thread-create
-//    callbacks to associate logical thread-ids (0,1,2...) with threads. Users
-//    may rely on thread 0 always being the main thread.
-//    In contrast, the order from ICorDebugProcess::EnumerateThreads is random.
-//
-//    Compare to code:ShimProcess::QueueFakeThreadAttachEventsNoOrder, which
-//    sends the threads in an arbitrary order.
-HRESULT ShimProcess::QueueFakeThreadAttachEventsNativeOrder()
-{
-#ifdef FEATURE_CORESYSTEM
-    _ASSERTE("NYI");
-    return E_FAIL;
-#else
-    ICorDebugProcess * pProcess = GetProcess();
-
-    DWORD dwProcessId;
-    HRESULT hr = pProcess->GetID(&dwProcessId);
-    SIMPLIFYING_ASSUMPTION_SUCCEEDED(hr);
-    if (FAILED(hr))
-    {
-        return hr;
-    }
-
-    HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
-    THREADENTRY32 te32;
-
-    // Take a snapshot of all running threads
-    hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
-    if (hThreadSnap == INVALID_HANDLE_VALUE)
-    {
-        hr = HRESULT_FROM_GetLastError();
-        SIMPLIFYING_ASSUMPTION_SUCCEEDED(hr);
-        return hr;
-    }
-    // HandleHolder doesn't deal with INVALID_HANDLE_VALUE, so we only assign if we have a legal value.
-    HandleHolder hSnapshotHolder(hThreadSnap);
-
-    // Fill in the size of the structure before using it.
-    te32.dwSize = sizeof(THREADENTRY32);
-
-    // Retrieve information about the first thread, and exit if unsuccessful
-    if (!Thread32First(hThreadSnap, &te32))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        return hr;
-    }
-
-    // Now walk the thread list of the system,
-    // and display information about each thread
-    // associated with the specified process
-    do
-    {
-        if (te32.th32OwnerProcessID == dwProcessId)
-        {
-            RSExtSmartPtr<ICorDebugThread> pThread;
-            pProcess->GetThread(te32.th32ThreadID, &pThread);
-            if (pThread != NULL)
-            {
-                // If we fail to get the appdomain for some reason, then then
-                // we can't dispatch this thread callback. But we can still
-                // finish enumerating.
-                RSExtSmartPtr<ICorDebugAppDomain> pAppDomain;
-                HRESULT hrGetAppDomain = pThread->GetAppDomain(&pAppDomain);
-                SIMPLIFYING_ASSUMPTION_SUCCEEDED(hrGetAppDomain);
-                if (pAppDomain != NULL)
-                {
-                    GetShimCallback()->CreateThread(pAppDomain, pThread);
-                    AddDuplicateCreationEvent(pThread);
-
-                    //fix for issue DevDiv2\DevDiv 77523 - threads are switched out in SQL don't get thread create notifications
-                    // mark that this thread has queued a create event
-                    CordbThread* pThreadInternal = static_cast<CordbThread*>(pThread.GetValue());
-                    pThreadInternal->SetCreateEventQueued();
-                }
-            }
-        }
-    } while(Thread32Next(hThreadSnap, &te32));
-
-
-    //fix for issue DevDiv2\DevDiv 77523 - threads are switched out in SQL don't get thread create notifications
-    //
-
-
-    // Threads which were switched out won't be present in the native thread order enumeration above.
-    // In order to not miss them we will enumerate all the managed thread objects and for any that we haven't
-    // already queued a notification for, we will queue a notification now.
-    RSExtSmartPtr<ICorDebugThreadEnum> pThreadEnum;
-    RSExtSmartPtr<ICorDebugThread> pThread;
-    hr = pProcess->EnumerateThreads(&pThreadEnum);
-    if (FAILED(hr))
-    {
-        return hr;
-    }
-
-    ULONG cDummy;
-
-    while(SUCCEEDED(pThreadEnum->Next(1, &pThread, &cDummy)) && (pThread != NULL))
-    {
-        RSExtSmartPtr<ICorDebugAppDomain> pAppDomain;
-        hr = pThread->GetAppDomain(&pAppDomain);
-        CordbThread* pThreadInternal = static_cast<CordbThread*>(pThread.GetValue());
-
-        // Getting the appdomain shouldn't fail. If it does, we can't dispatch
-        // this callback, but we can still dispatch the other thread creates.
-        SIMPLIFYING_ASSUMPTION_SUCCEEDED(hr);
-        if (pAppDomain != NULL && !pThreadInternal->CreateEventWasQueued())
-        {
-            GetShimCallback()->CreateThread(pAppDomain, pThread);
-            AddDuplicateCreationEvent(pThread);
-            pThreadInternal->SetCreateEventQueued();
-        }
-        pThread.Clear();
-    }
-
-
-    return S_OK;
-#endif
-}
-
 //---------------------------------------------------------------------------------------
 // Queues the fake Assembly and Module load events
 //
@@ -1476,15 +1337,9 @@ void ShimProcess::QueueFakeAttachEvents()
     //
     // Third, Queue all Threads
     //
-#if !defined(FEATURE_DBGIPC_TRANSPORT_DI) && !defined(FEATURE_CORESYSTEM)
-    // Use OS thread enumeration facilities to ensure that the managed thread
-    // thread order is the same as the corresponding native thread order.
-    QueueFakeThreadAttachEventsNativeOrder();
-#else
     // Use ICorDebug to enumerate threads. The order of managed threads may
     // not match the order the threads were created in.
     QueueFakeThreadAttachEventsNoOrder();
-#endif
 
     // Forth, Queue all Connections.
     // Enumerate connections is not exposed through ICorDebug, so we need to go use a private hook on CordbProcess.
@@ -1730,86 +1585,6 @@ void ShimProcess::PreDispatchEvent(bool fRealCreateProcessEvent /*= false*/)
 
 }
 
-// ----------------------------------------------------------------------------
-// ShimProcess::GetCLRInstanceBaseAddress
-// Finds the base address of [core]clr.dll
-// Arguments: none
-// Return value: returns the base address of [core]clr.dll if possible or NULL otherwise
-//
-CORDB_ADDRESS ShimProcess::GetCLRInstanceBaseAddress()
-{
-    CORDB_ADDRESS baseAddress = CORDB_ADDRESS(NULL);
-    DWORD dwPid = m_pLiveDataTarget->GetPid();
-
-#if defined(FEATURE_CORESYSTEM)
-    // Debugger attaching to CoreCLR via CoreCLRCreateCordbObject should have already specified CLR module address.
-    // Code that help to find it now lives in dbgshim.
-#else
-    // get a "snapshot" of all modules in the target
-    HandleHolder hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPid);
-    MODULEENTRY32 moduleEntry = { 0 };
-
-    if (hSnapshot == INVALID_HANDLE_VALUE)
-    {
-        // we haven't got a loaded CLR yet
-        baseAddress = CORDB_ADDRESS(NULL);
-    }
-    else
-    {
-        // we need to loop through the modules until we find mscorwks.dll
-        moduleEntry.dwSize = sizeof(MODULEENTRY32);
-
-        if (!Module32First(hSnapshot, &moduleEntry))
-        {
-            baseAddress = CORDB_ADDRESS(NULL);
-        }
-        else
-        {
-
-            do
-            {
-                if (!_wcsicmp(moduleEntry.szModule, MAKEDLLNAME_W(MAIN_CLR_MODULE_NAME_W)))
-                {
-                    // we found it, so save the base address
-                    baseAddress = PTR_TO_CORDB_ADDRESS(moduleEntry.modBaseAddr);
-                }
-            } while (Module32Next(hSnapshot, &moduleEntry));
-        }
-    }
-#endif
-    return baseAddress;
-} // ShimProcess::GetCLRInstanceBaseAddress
-
-// ----------------------------------------------------------------------------
-// ShimProcess::FindLoadedCLR
-//
-// Description:
-//    Look for any CLR loaded into the process.  If found, return the instance ID for it.
-//
-// Arguments:
-//    * pClrInstanceId - out parameter for the instance ID of the CLR
-//
-// Return Value:
-//    Returns S_OK if a CLR was found, and stores its instance ID in pClrInstanceId.
-//    Otherwise returns an error code.
-//
-// Notes:
-//    If there are multiple CLRs loaded in the process, the one chosen for the returned
-//    instance ID is unspecified.
-//
-HRESULT ShimProcess::FindLoadedCLR(CORDB_ADDRESS * pClrInstanceId)
-{
-    *pClrInstanceId = GetCLRInstanceBaseAddress();
-
-    if (*pClrInstanceId == 0)
-    {
-        return E_UNEXPECTED;
-    }
-
-    return S_OK;
-}
-
-
 //---------------------------------------------------------------------------------------
 //
 // Locates DAC by finding mscordac{wks|core} next to DBI
diff --git a/src/coreclr/debug/di/windowspipeline.cpp b/src/coreclr/debug/di/windowspipeline.cpp
index cea89e73874001..68ac4a216c6605 100644
--- a/src/coreclr/debug/di/windowspipeline.cpp
+++ b/src/coreclr/debug/di/windowspipeline.cpp
@@ -92,14 +92,7 @@ class WindowsNativePipeline :
     // Terminate the debuggee process.
     virtual BOOL TerminateProcess(UINT32 exitCode);
 
-    // Resume any suspended threads
-    virtual HRESULT EnsureThreadsRunning();
-
 protected:
-    void UpdateDebugSetProcessKillOnExit();
-
-    HRESULT IsRemoteDebuggerPresent(DWORD processId, BOOL* pfDebuggerPresent);
-
     // Cached value from DebugSetProcessKillOnExit.
     // This is thread-local, and impacts all debuggees on the thread.
     bool m_fKillOnExit;
@@ -125,46 +118,10 @@ BOOL WindowsNativePipeline::DebugSetProcessKillOnExit(bool fKillOnExit)
 {
     // Can't call kernel32!DebugSetProcessKillOnExit until after the event thread
     // has spawned a debuggee. So cache the value now and call it later.
-    // This bit is enforced in code:WindowsNativePipeline::UpdateDebugSetProcessKillOnExit
     m_fKillOnExit = fKillOnExit;
     return TRUE;
 }
 
-// Enforces the bit set in code:WindowsNativePipeline::DebugSetProcessKillOnExit
-void WindowsNativePipeline::UpdateDebugSetProcessKillOnExit()
-{
-#if !defined(FEATURE_CORESYSTEM)
-    // Late bind to DebugSetProcessKillOnExit - WinXP and above only
-    HModuleHolder hKernel32;
-    hKernel32 = WszLoadLibrary(W("kernel32"));
-    SIMPLIFYING_ASSUMPTION(hKernel32 != NULL);
-    if (hKernel32 == NULL)
-        return;
-
-    typedef BOOL (*DebugSetProcessKillOnExitSig) (BOOL);
-    DebugSetProcessKillOnExitSig pDebugSetProcessKillOnExit =
-        reinterpret_cast<DebugSetProcessKillOnExitSig>(GetProcAddress(hKernel32, "DebugSetProcessKillOnExit"));
-
-    // If the API doesn't exist (eg. Win2k) - there isn't anything we can do, just
-    // silently ignore the request.
-    if (pDebugSetProcessKillOnExit == NULL)
-        return;
-
-    BOOL ret = pDebugSetProcessKillOnExit(m_fKillOnExit);
-
-    // Not a good failure path here.
-    // 1) This shouldn't fail.
-    // 2) Even if it does, this is likely called after the debuggee
-    // has already been created, and if this API fails, most scenarios will
-    // be unaffected, so we don't want to fail the overall debugging session.
-    SIMPLIFYING_ASSUMPTION(ret);
-
-#else
-	// The API doesn't exit on CoreSystem, just return
-	return;
-#endif
-}
-
 // Create an process under the debugger.
 HRESULT WindowsNativePipeline::CreateProcessUnderDebugger(
     MachineInfo machineInfo,
@@ -199,7 +156,6 @@ HRESULT WindowsNativePipeline::CreateProcessUnderDebugger(
     }
 
     m_dwProcessId = lpProcessInformation->dwProcessId;
-    UpdateDebugSetProcessKillOnExit();
     return S_OK;
 }
 
@@ -213,104 +169,23 @@ HRESULT WindowsNativePipeline::DebugActiveProcess(MachineInfo machineInfo, const
     {
         hr = S_OK;
         m_dwProcessId = processDescriptor.m_Pid;
-        UpdateDebugSetProcessKillOnExit();
     }
     else
     {
         hr = HRESULT_FROM_GetLastError();
-
-        // There are at least two scenarios in which DebugActiveProcess() returns E_INVALIDARG:
-        //     1) if the specified process doesn't exist, or
-        //     2) if the specified process already has a debugger atttached
-        // We need to distinguish these two cases in order to return the correct HR.
-        if (hr == E_INVALIDARG)
-        {
-            // Check whether a debugger is known to be already attached.
-            // Note that this API won't work on some OSes, in which case we err on the side of returning E_INVALIDARG
-            // even though a debugger may be attached.  Another approach could be to assume that if
-            // OpenProcess succeeded, then DebugActiveProcess must only have failed because a debugger is
-            // attached.  But I think it's better to only return the specific error code if we know for sure
-            // the case is true.
-            BOOL fIsDebuggerPresent = FALSE;
-            if (SUCCEEDED(IsRemoteDebuggerPresent(processDescriptor.m_Pid, &fIsDebuggerPresent)))
-            {
-                if (fIsDebuggerPresent)
-                {
-                    hr = CORDBG_E_DEBUGGER_ALREADY_ATTACHED;
-                }
-            }
-        }
     }
 
     return hr;
 }
 
-// Determine (if possible) whether a debugger is attached to the target process
-HRESULT WindowsNativePipeline::IsRemoteDebuggerPresent(DWORD processId, BOOL* pfDebuggerPresent)
-{
-#if !defined(FEATURE_CORESYSTEM)
-
-    // Get a process handle for the process ID.
-    HandleHolder hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, processId);
-    if (hProc == NULL)
-        return HRESULT_FROM_GetLastError();
-
-    // Delay-bind to CheckRemoteDebuggerPresent - WinXP SP1 and above only
-    HModuleHolder hKernel32;
-    hKernel32 = WszLoadLibrary(W("kernel32"));
-    if (hKernel32 == NULL)
-        return HRESULT_FROM_GetLastError();
-
-    typedef BOOL (*CheckRemoteDebuggerPresentSig) (HANDLE, PBOOL);
-    CheckRemoteDebuggerPresentSig pCheckRemoteDebuggerPresent =
-        reinterpret_cast<CheckRemoteDebuggerPresentSig>(GetProcAddress(hKernel32, "CheckRemoteDebuggerPresent"));
-    if (pCheckRemoteDebuggerPresent == NULL)
-        return HRESULT_FROM_GetLastError();
-
-    // API exists - call it
-    if (!pCheckRemoteDebuggerPresent(hProc, pfDebuggerPresent))
-        return HRESULT_FROM_GetLastError();
-
-    return S_OK;
-#else
-
-	//CoreSystem doesn't have this API
-	return E_FAIL;
-#endif
-}
-
 // Detach
 HRESULT WindowsNativePipeline::DebugActiveProcessStop(DWORD processId)
 {
-#if !defined(FEATURE_CORESYSTEM)
-    // Late-bind to DebugActiveProcessStop since it's WinXP and above only
-    HModuleHolder hKernel32;
-    hKernel32 = WszLoadLibrary(W("kernel32"));
-    if (hKernel32 == NULL)
-        return HRESULT_FROM_GetLastError();
-
-    typedef BOOL (*DebugActiveProcessStopSig) (DWORD);
-    DebugActiveProcessStopSig pDebugActiveProcessStop =
-        reinterpret_cast<DebugActiveProcessStopSig>(GetProcAddress(hKernel32, "DebugActiveProcessStop"));
-
-    // Win2K will fail here - can't find DebugActiveProcessStop
-    if (pDebugActiveProcessStop == NULL)
-        return HRESULT_FROM_GetLastError();
-
-    // Ok, the API exists, call it
-    if (!pDebugActiveProcessStop(processId))
-    {
-        // Detach itself failed
-        return HRESULT_FROM_GetLastError();
-    }
-#else
-	// The API exists, call it
     if (!::DebugActiveProcessStop(processId))
     {
         // Detach itself failed
         return HRESULT_FROM_GetLastError();
     }
-#endif
     return S_OK;
 }
 
@@ -359,60 +234,3 @@ BOOL WindowsNativePipeline::TerminateProcess(UINT32 exitCode)
 
     return ::TerminateProcess(hProc, exitCode);
 }
-
-// Resume any suspended threads (but just once)
-HRESULT WindowsNativePipeline::EnsureThreadsRunning()
-{
-#ifdef FEATURE_CORESYSTEM
-	_ASSERTE("NYI");
-	return E_FAIL;
-#else
-    _ASSERTE(m_dwProcessId != 0);
-
-    // Take a snapshot of all running threads (similar to ShimProcess::QueueFakeThreadAttachEventsNativeOrder)
-    // Alternately we could return thread creation/exit in WaitForDebugEvent.  But we expect this to be used
-    // very rarely, so no need to complicate more common codepaths.
-    HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
-    THREADENTRY32 te32;
-
-    hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
-    if (hThreadSnap == INVALID_HANDLE_VALUE)
-        return HRESULT_FROM_GetLastError();
-
-    // HandleHolder doesn't deal with INVALID_HANDLE_VALUE, so we only assign if we have a legal value.
-    HandleHolder hSnapshotHolder(hThreadSnap);
-
-    // Fill in the size of the structure before using it.
-    te32.dwSize = sizeof(THREADENTRY32);
-
-    // Retrieve information about the first thread, and exit if unsuccessful
-    if (!Thread32First(hThreadSnap, &te32))
-        return HRESULT_FROM_GetLastError();
-
-    // Now walk the thread list of the system and attempt to resume any that are part of this process
-    // Ignore errors - this is a best effort (but ASSERT in CHK builds since we don't expect errors
-    // in practice - we expect the process to be frozen at a debug event, so no races etc.)
-
-    HRESULT hr = S_FALSE;   // no thread was resumed
-    do
-    {
-        if (te32.th32OwnerProcessID == m_dwProcessId)
-        {
-            HandleHolder hThread = ::OpenThread(THREAD_SUSPEND_RESUME, FALSE, te32.th32ThreadID);
-            _ASSERTE(hThread != NULL);
-            if (hThread != NULL)
-            {
-                // Resume each thread exactly once (if they were suspended multiple times,
-                // then EnsureThreadsRunning would need to be called multiple times until it
-                // returned S_FALSE.
-                DWORD prevCount = ::ResumeThread(hThread);
-                _ASSERTE(prevCount >= 0);
-                if (prevCount >= 1)
-                    hr = S_OK;      // some thread was resumed
-            }
-        }
-    } while(Thread32Next(hThreadSnap, &te32));
-
-    return hr;
-#endif
-}
diff --git a/src/coreclr/debug/ee/rcthread.cpp b/src/coreclr/debug/ee/rcthread.cpp
index 0f48eb2c95e188..961b06c879f952 100644
--- a/src/coreclr/debug/ee/rcthread.cpp
+++ b/src/coreclr/debug/ee/rcthread.cpp
@@ -513,19 +513,6 @@ HRESULT DebuggerRCThread::SetupRuntimeOffsets(DebuggerIPCControlBlock * pDebugge
     pDebuggerRuntimeOffsets->m_excepNotForRuntimeBPAddr = (void*) ExceptionNotForRuntimeFlare;
     pDebuggerRuntimeOffsets->m_notifyRSOfSyncCompleteBPAddr = (void*) NotifyRightSideOfSyncCompleteFlare;
     pDebuggerRuntimeOffsets->m_debuggerWordTLSIndex = g_debuggerWordTLSIndex;
-
-#if !defined(FEATURE_CORESYSTEM)
-    // Grab the address of RaiseException in kernel32 because we have to play some games with exceptions
-    // that are generated there (just another reason why mixed mode debugging is shady). See bug 476768.
-    HMODULE hModule = WszGetModuleHandle(W("kernel32.dll"));
-    _ASSERTE(hModule != NULL);
-    PREFAST_ASSUME(hModule != NULL);
-    pDebuggerRuntimeOffsets->m_raiseExceptionAddr = GetProcAddress(hModule, "RaiseException");
-    _ASSERTE(pDebuggerRuntimeOffsets->m_raiseExceptionAddr != NULL);
-    hModule = NULL;
-#else
-    pDebuggerRuntimeOffsets->m_raiseExceptionAddr = NULL;
-#endif
 #endif // FEATURE_INTEROP_DEBUGGING
 
     pDebuggerRuntimeOffsets->m_pPatches = DebuggerController::GetPatchTable();
@@ -575,14 +562,14 @@ static LONG _debugFilter(LPEXCEPTION_POINTERS ep, PVOID pv)
 
     SUPPRESS_ALLOCATION_ASSERTS_IN_THIS_SCOPE;
 
-#if defined(_DEBUG) || !defined(FEATURE_CORESYSTEM)
+#if defined(_DEBUG)
     DebuggerIPCEvent *event = ((DebugFilterParam *)pv)->event;
 
     DWORD pid = GetCurrentProcessId();
     DWORD tid = GetCurrentThreadId();
 
     DebuggerIPCEventType type = (DebuggerIPCEventType) (event->type & DB_IPCE_TYPE_MASK);
-#endif // _DEBUG || !FEATURE_CORESYSTEM
+#endif // _DEBUG
 
     // We should never AV here. In a debug build, throw up an assert w/ lots of useful (private) info.
 #ifdef _DEBUG
@@ -613,18 +600,6 @@ static LONG _debugFilter(LPEXCEPTION_POINTERS ep, PVOID pv)
     }
 #endif
 
-// this message box doesn't work well on coresystem... we actually get in a recursive exception handling loop
-#ifndef FEATURE_CORESYSTEM
-    // We took an AV on the helper thread. This is a catastrophic situation so we can
-    // simply call the EE's catastrophic message box to display the error.
-    EEMessageBoxCatastrophic(
-        IDS_DEBUG_UNHANDLEDEXCEPTION_IPC, IDS_DEBUG_SERVICE_CAPTION,
-        type,
-        ep->ExceptionRecord->ExceptionCode,
-        GetIP(ep->ContextRecord),
-        pid, pid, tid, tid);
-#endif
-
     // For debugging, we can change the behavior by manually setting eax.
     // EXCEPTION_EXECUTE_HANDLER=1, EXCEPTION_CONTINUE_SEARCH=0, EXCEPTION_CONTINUE_EXECUTION=-1
     return EXCEPTION_CONTINUE_SEARCH;
diff --git a/src/coreclr/debug/inc/dbgipcevents.h b/src/coreclr/debug/inc/dbgipcevents.h
index ddef09554cf80d..39b34cb56b9655 100644
--- a/src/coreclr/debug/inc/dbgipcevents.h
+++ b/src/coreclr/debug/inc/dbgipcevents.h
@@ -126,7 +126,6 @@ struct MSLAYOUT DebuggerIPCRuntimeOffsets
     void   *m_signalHijackCompleteBPAddr;
     void   *m_excepNotForRuntimeBPAddr;
     void   *m_notifyRSOfSyncCompleteBPAddr;
-    void   *m_raiseExceptionAddr;                       // The address of kernel32!RaiseException in the debuggee
     DWORD   m_debuggerWordTLSIndex;                     // The TLS slot for the debugger word used in the debugger hijack functions
 #endif // FEATURE_INTEROP_DEBUGGING
     SIZE_T  m_TLSIndex;                                 // The TLS index of the thread-local storage for coreclr.dll
@@ -364,30 +363,6 @@ struct MSLAYOUT DebuggerIPCControlBlockTransport
 #include "dbgtransportsession.h"
 #endif // defined(FEATURE_DBGIPC_TRANSPORT_VM) || defined(FEATURE_DBGIPC_TRANSPORT_DI)
 
-#if defined(TARGET_X86) && !defined(FEATURE_CORESYSTEM)
-// We have an versioning requirement.
-// Certain portions of the v1.0 and v1.1 IPC block are shared. This is b/c a v1.1 debugger needs to be able
-// to look at a v2.0 app enough to recognize the version mismatch.
-// This check is only necessary for platforms that ran on v1.1 (Win32-x86)
-
-// Just to catch any potential illegal change in the IPC block, we assert the offsets against the offsets from v1.1.
-// The constants here are pulled from v1.1.
-// The RS will look at these versioning fields, so they absolutely must line up.
-static_assert_no_msg(offsetof(DebuggerIPCControlBlock, m_leftSideProtocolCurrent) == 0x10);
-static_assert_no_msg(offsetof(DebuggerIPCControlBlock, m_leftSideProtocolMinSupported) == 0x14);
-static_assert_no_msg(offsetof(DebuggerIPCControlBlock, m_rightSideProtocolCurrent) == 0x18);
-static_assert_no_msg(offsetof(DebuggerIPCControlBlock, m_rightSideProtocolMinSupported) == 0x1c);
-
-// Unfortunately, on detecting such failure, v1.1 will also null out LSEA, LSER and RSPH.
-// If these get adjusted, a version-mismatch attach  will effectively null out random fields.
-static_assert_no_msg(offsetof(DebuggerIPCControlBlock, m_paddingObsoleteLSEA) == 0x30);
-static_assert_no_msg(offsetof(DebuggerIPCControlBlock, m_paddingObsoleteLSER) == 0x34);
-static_assert_no_msg(offsetof(DebuggerIPCControlBlock, m_rightSideProcessHandle) == 0x38);
-
-
-
-#endif
-
 #define INITIAL_APP_DOMAIN_INFO_LIST_SIZE   16
 
 
diff --git a/src/coreclr/debug/shared/dbgtransportsession.cpp b/src/coreclr/debug/shared/dbgtransportsession.cpp
index 6d3ed5b345cf7c..3ff580717e72a8 100644
--- a/src/coreclr/debug/shared/dbgtransportsession.cpp
+++ b/src/coreclr/debug/shared/dbgtransportsession.cpp
@@ -2696,11 +2696,6 @@ bool DbgTransportSession::DbgTransportShouldInjectFault(DbgTransportFaultOp eOp,
         if (dwChance < (s_dwFaultInjection & DBG_TRANSPORT_FAULT_RATE_MASK))
         {
             DbgTransportLog(LC_FaultInject, "Injected fault for %s operation", szOpName);
-#if defined(FEATURE_CORESYSTEM)
-        // not supported
-#else
-            WSASetLastError(WSAEFAULT);
-#endif // defined(FEATURE_CORESYSTEM)
             return true;
         }
     }
diff --git a/src/coreclr/dlls/dbgshim/dbgshim.cpp b/src/coreclr/dlls/dbgshim/dbgshim.cpp
index 40e4d7dea4bf26..c82625487cfe85 100644
--- a/src/coreclr/dlls/dbgshim/dbgshim.cpp
+++ b/src/coreclr/dlls/dbgshim/dbgshim.cpp
@@ -1956,9 +1956,7 @@ GetContinueStartupEvent(
 
 #endif // !TARGET_UNIX
 
-#if defined(FEATURE_CORESYSTEM)
 #include "debugshim.h"
-#endif
 
 //-----------------------------------------------------------------------------
 // Public API.
@@ -1980,26 +1978,17 @@ CLRCreateInstance(
 {
     PUBLIC_CONTRACT;
 
-#if defined(FEATURE_CORESYSTEM)
-
     if (ppInterface == NULL)
         return E_POINTER;
 
     if (clsid != CLSID_CLRDebugging || riid != IID_ICLRDebugging)
         return E_NOINTERFACE;
 
-#if defined(FEATURE_CORESYSTEM)
     GUID skuId = CLR_ID_ONECORE_CLR;
-#else
-    GUID skuId = CLR_ID_CORECLR;
-#endif
 
     CLRDebuggingImpl *pDebuggingImpl = new (nothrow) CLRDebuggingImpl(skuId);
     if (NULL == pDebuggingImpl)
         return E_OUTOFMEMORY;
 
     return pDebuggingImpl->QueryInterface(riid, ppInterface);
-#else
-    return E_NOTIMPL;
-#endif
 }
diff --git a/src/coreclr/inc/bbsweep.h b/src/coreclr/inc/bbsweep.h
index 4e3636681e4e4b..64855ed939ddd7 100644
--- a/src/coreclr/inc/bbsweep.h
+++ b/src/coreclr/inc/bbsweep.h
@@ -182,97 +182,6 @@ class BBSweep
         if (!bInitialized)
         {
             SECURITY_ATTRIBUTES * pSecurityAttributes = NULL;
-
-#ifndef FEATURE_CORESYSTEM // @CORESYSTEMTODO
-            PSECURITY_DESCRIPTOR pSD = NULL;
-            PSID pAdminSid = NULL;
-            HANDLE hToken = NULL;
-            PACL pACL = NULL;
-            LPVOID buffer = NULL;
-
-            if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
-                goto cleanup;
-
-            // don't set pSecurityAttributes for AppContainer processes
-            if(!IsAppContainerProcess(hToken))
-            {
-                SECURITY_ATTRIBUTES securityAttributes;
-                PSID pUserSid = NULL;
-                SID_IDENTIFIER_AUTHORITY SIDAuthNT = SECURITY_NT_AUTHORITY;
-                DWORD retLength;
-
-#ifdef _PREFAST_
-#pragma warning(push)
-#pragma warning(disable:6211) // PREfast warning: Leaking memory 'pSD' due to an exception.
-#endif /*_PREFAST_ */
-                pSD = (PSECURITY_DESCRIPTOR) new char[SECURITY_DESCRIPTOR_MIN_LENGTH];
-                if (!pSD)
-                    goto cleanup;
-
-                if (GetTokenInformation(hToken, TokenOwner, NULL, 0, &retLength))
-                    goto cleanup;
-
-                buffer = (LPVOID) new char[retLength];
-                if (!buffer)
-                    goto cleanup;
-#ifdef _PREFAST_
-#pragma warning(pop)
-#endif /*_PREFAST_*/
-
-                // Get the SID for the current user
-                if (!GetTokenInformation(hToken, TokenOwner, (LPVOID) buffer, retLength, &retLength))
-                    goto cleanup;
-
-                pUserSid = ((TOKEN_OWNER *) buffer)->Owner;
-
-                // Get the SID for the admin group
-                // Create a SID for the BUILTIN\Administrators group.
-                if(! AllocateAndInitializeSid(&SIDAuthNT, 2,
-                    SECURITY_BUILTIN_DOMAIN_RID,
-                    DOMAIN_ALIAS_RID_ADMINS,
-                    0, 0, 0, 0, 0, 0,
-                    &pAdminSid))
-                    goto cleanup;
-
-                EXPLICIT_ACCESS ea[2];
-                ZeroMemory(ea, 2 * sizeof(EXPLICIT_ACCESS));
-
-                // Initialize an EXPLICIT_ACCESS structure for an ACE.
-                // The ACE will allow the current user full access
-                ea[0].grfAccessPermissions = STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL; // KEY_ALL_ACCESS;
-                ea[0].grfAccessMode = SET_ACCESS;
-                ea[0].grfInheritance= NO_INHERITANCE;
-                ea[0].Trustee.TrusteeForm = TRUSTEE_IS_SID;
-                ea[0].Trustee.TrusteeType = TRUSTEE_IS_USER;
-                ea[0].Trustee.ptstrName  = (LPTSTR) pUserSid;
-
-                // Initialize an EXPLICIT_ACCESS structure for an ACE.
-                // The ACE will allow admins full access
-                ea[1].grfAccessPermissions = STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL; //KEY_ALL_ACCESS;
-                ea[1].grfAccessMode = SET_ACCESS;
-                ea[1].grfInheritance= NO_INHERITANCE;
-                ea[1].Trustee.TrusteeForm = TRUSTEE_IS_SID;
-                ea[1].Trustee.TrusteeType = TRUSTEE_IS_GROUP;
-                ea[1].Trustee.ptstrName  = (LPTSTR) pAdminSid;
-
-                if (SetEntriesInAcl(2, ea, NULL, &pACL) != ERROR_SUCCESS)
-                    goto cleanup;
-
-                if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION))
-                    goto cleanup;
-
-                if (!SetSecurityDescriptorDacl(pSD, TRUE, pACL, FALSE))
-                    goto cleanup;
-
-                memset((void *) &securityAttributes, 0, sizeof(SECURITY_ATTRIBUTES));
-                securityAttributes.nLength              = sizeof(SECURITY_ATTRIBUTES);
-                securityAttributes.lpSecurityDescriptor = pSD;
-                securityAttributes.bInheritHandle       = FALSE;
-
-                pSecurityAttributes = &securityAttributes;
-            }
-#endif // !FEATURE_CORESYSTEM
-
             WCHAR objectName[MAX_LONGPATH] = {0};
             WCHAR objectNamePrefix[MAX_LONGPATH] = {0};
             GetObjectNamePrefix(processID, fromRuntime, objectNamePrefix);
@@ -291,14 +200,6 @@ class BBSweep
             hTerminationEvent    = ::WszCreateEvent(pSecurityAttributes, true, false, NULL);
             swprintf_s(objectName, MAX_LONGPATH, W("%sBBSweep_hProfWriterSemaphore"), objectNamePrefix);
             hProfWriterSemaphore = ::WszCreateSemaphore(pSecurityAttributes, MAX_COUNT, MAX_COUNT, objectName);
-
-#ifndef FEATURE_CORESYSTEM // @CORESYSTEMTODO
-cleanup:
-            if (pSD) delete [] ((char *) pSD);
-            if (pAdminSid) FreeSid(pAdminSid);
-            if (hToken) CloseHandle(hToken);
-            if (buffer) delete [] ((char *) buffer);
-#endif
         }
 
         bInitialized = hSweepMutex          &&
@@ -378,7 +279,7 @@ class BBSweep
                 }
                 else
                 {
-#if defined (FEATURE_CORESYSTEM) && !defined(DACCESS_COMPILE)
+#if !defined(DACCESS_COMPILE)
 #define MODULE_NAME W("api-ms-win-security-appcontainer-l1-1-0.dll")
 #else
 #define MODULE_NAME W("kernel32.dll")
diff --git a/src/coreclr/inc/clrconfigvalues.h b/src/coreclr/inc/clrconfigvalues.h
index e1edb2466e65c8..e544430fa587ba 100644
--- a/src/coreclr/inc/clrconfigvalues.h
+++ b/src/coreclr/inc/clrconfigvalues.h
@@ -176,7 +176,6 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_DbgDACSkipVerifyDlls, W("DbgDACSkipVerifyDlls"
 CONFIG_DWORD_INFO(INTERNAL_DbgDelayHelper, W("DbgDelayHelper"), 0, "Varies the wait in the helper thread startup for testing race between threads")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_DbgDisableDynamicSymsCompat, W("DbgDisableDynamicSymsCompat"), 0, "")
 CONFIG_DWORD_INFO(INTERNAL_DbgDisableTargetConsistencyAsserts, W("DbgDisableTargetConsistencyAsserts"), 0, "Allows explicitly testing with corrupt targets")
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_DbgEnableMixedModeDebugging, W("DbgEnableMixedModeDebuggingInternalOnly"), 0, "")
 CONFIG_DWORD_INFO(INTERNAL_DbgExtraThreads, W("DbgExtraThreads"), 0, "Allows extra unmanaged threads to run and throw debug events for stress testing")
 CONFIG_DWORD_INFO(INTERNAL_DbgExtraThreadsCantStop, W("DbgExtraThreadsCantStop"), 0, "Allows extra unmanaged threads in can't stop region to run and throw debug events for stress testing")
 CONFIG_DWORD_INFO(INTERNAL_DbgExtraThreadsIB, W("DbgExtraThreadsIB"), 0, "Allows extra in-band unmanaged threads to run and throw debug events for stress testing")
diff --git a/src/coreclr/inc/clrtypes.h b/src/coreclr/inc/clrtypes.h
index 6050936814e6fa..5e83573e7aa943 100644
--- a/src/coreclr/inc/clrtypes.h
+++ b/src/coreclr/inc/clrtypes.h
@@ -11,7 +11,7 @@
 #ifndef CLRTYPES_H_
 #define CLRTYPES_H_
 
-#if defined(_MSC_VER) && !defined(SOURCE_FORMATTING) && defined(FEATURE_CORESYSTEM)
+#if defined(_MSC_VER) && !defined(SOURCE_FORMATTING)
     // Prefer intsafe.h when available, which defines many of the MAX/MIN
     // values below (which is why they are in #ifndef blocks).
     #include <intsafe.h>
diff --git a/src/coreclr/inc/ostype.h b/src/coreclr/inc/ostype.h
index ddb0ec5d01b8ef..78494c71c2b66e 100644
--- a/src/coreclr/inc/ostype.h
+++ b/src/coreclr/inc/ostype.h
@@ -31,20 +31,6 @@ extern RunningOnStatusEnum gRunningOnStatus;
 
 void InitRunningOnVersionStatus();
 
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORESYSTEM)
-typedef enum
-{
-    WINRT_STATUS_UNINITED = 0,
-    WINRT_STATUS_UNSUPPORTED,
-    WINRT_STATUS_SUPPORTED
-}
-WinRTStatusEnum;
-
-extern WinRTStatusEnum      gWinRTStatus;
-
-void InitWinRTStatus();
-#endif // FEATURE_COMINTEROP && !FEATURE_CORESYSTEM
-
 //*****************************************************************************
 // Returns true if you are running on Windows 8 or newer.
 //*****************************************************************************
@@ -65,28 +51,10 @@ inline BOOL RunningOnWin8()
 
 #ifdef FEATURE_COMINTEROP
 
-#ifdef FEATURE_CORESYSTEM
-
 inline BOOL WinRTSupported()
 {
     return RunningOnWin8();
 }
-#else
-inline BOOL WinRTSupported()
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_CANNOT_TAKE_LOCK;
-
-
-    if (gWinRTStatus == WINRT_STATUS_UNINITED)
-    {
-        InitWinRTStatus();
-    }
-
-    return gWinRTStatus == WINRT_STATUS_SUPPORTED;
-}
-#endif // FEATURE_CORESYSTEM
 
 #endif // FEATURE_COMINTEROP
 
diff --git a/src/coreclr/inc/switches.h b/src/coreclr/inc/switches.h
index 65cda94ed9900b..081299e7bfdbc4 100644
--- a/src/coreclr/inc/switches.h
+++ b/src/coreclr/inc/switches.h
@@ -165,9 +165,7 @@
 #define FEATURE_DOUBLE_ALIGNMENT_HINT
 #endif
 
-#if defined(FEATURE_CORESYSTEM)
 #define FEATURE_MINIMETADATA_IN_TRIAGEDUMPS
-#endif // defined(FEATURE_CORESYSTEM)
 
 // If defined, support interpretation.
 
diff --git a/src/coreclr/inc/winwrap.h b/src/coreclr/inc/winwrap.h
index 3bf11baea318b3..0c1b7c22459ceb 100644
--- a/src/coreclr/inc/winwrap.h
+++ b/src/coreclr/inc/winwrap.h
@@ -188,16 +188,11 @@
 #define WszWideCharToMultiByte WideCharToMultiByte
 #define WszCreateSemaphore(_secattr, _count, _maxcount, _name) CreateSemaphoreExW((_secattr), (_count), (_maxcount), (_name), 0, MAXIMUM_ALLOWED | SYNCHRONIZE | SEMAPHORE_MODIFY_STATE)
 
-#ifdef FEATURE_CORESYSTEM
-
-// CoreSystem has GetFileVersionInfo{Size}Ex but not GetFileVersionInfoSize{Size}
 #undef GetFileVersionInfo
 #define GetFileVersionInfo(_filename, _handle, _len, _data) GetFileVersionInfoEx(0, (_filename), (_handle), (_len), (_data))
 #undef GetFileVersionInfoSize
 #define GetFileVersionInfoSize(_filename, _handle) GetFileVersionInfoSizeEx(0, (_filename), (_handle))
 
-#endif // FEATURE_CORESYSTEM
-
 #ifndef _T
 #define _T(str) W(str)
 #endif
@@ -259,12 +254,6 @@ inline DWORD GetMaxDBCSCharByteSize()
 #endif // HOST_UNIX
 }
 
-#ifndef HOST_UNIX
-BOOL RunningInteractive();
-#else // !HOST_UNIX
-#define RunningInteractive() FALSE
-#endif // !HOST_UNIX
-
 #ifndef Wsz_mbstowcs
 #define Wsz_mbstowcs(szOut, szIn, iSize) WszMultiByteToWideChar(CP_ACP, 0, szIn, -1, szOut, iSize)
 #endif
@@ -481,11 +470,7 @@ inline int LateboundMessageBoxA(HWND hWnd,
     return LateboundMessageBoxW(hWnd, wszText, wszCaption, uType);
 }
 
-#if defined(FEATURE_CORESYSTEM)
-
 #define MessageBoxW LateboundMessageBoxW
 #define MessageBoxA LateboundMessageBoxA
 
-#endif // FEATURE_CORESYSTEM
-
 #endif  // __WIN_WRAP_H__
diff --git a/src/coreclr/nativeaot/Runtime/eventtracebase.h b/src/coreclr/nativeaot/Runtime/eventtracebase.h
index 79b8fac860612c..e4a16fd87d6e08 100644
--- a/src/coreclr/nativeaot/Runtime/eventtracebase.h
+++ b/src/coreclr/nativeaot/Runtime/eventtracebase.h
@@ -147,13 +147,6 @@ struct ProfilingScanContext;
 
 #ifndef FEATURE_REDHAWK
 
-#if defined(FEATURE_CORECLR) && !defined(FEATURE_CORESYSTEM)
-// For Silverlight non-CoreSys builds we still use an older toolset,
-// headers/libs, and a different value for WINVER. We use this symbol
-// to distinguish between whether we built the ETW header files from
-// the ETW manifest using the -mof command line or not.
-#define WINXP_AND_WIN2K3_BUILD_SUPPORT
-#endif
 #include "corprof.h"
 
 // g_nClrInstanceId is defined in Utilcode\Util.cpp. The definition goes into Utilcode.lib.
diff --git a/src/coreclr/utilcode/securitywrapper.cpp b/src/coreclr/utilcode/securitywrapper.cpp
index 8f7ac38f444a0e..67b462bf00a267 100644
--- a/src/coreclr/utilcode/securitywrapper.cpp
+++ b/src/coreclr/utilcode/securitywrapper.cpp
@@ -206,117 +206,6 @@ HRESULT GetSidFromProcessWorker(DWORD dwProcessId, SidType sidType, PSID *ppSid)
     return hr;
 }
 
-#ifndef FEATURE_CORESYSTEM
-//-----------------------------------------------------------------------------
-// get the sid of a given process id using WTSEnumerateProcesses
-// @todo: Make this function fail when WTSEnumerateProcesses is not available
-// Or is it always available on all of our platform?
-//
-// Caller remember to call delete on *ppSid
-//-----------------------------------------------------------------------------
-HRESULT GetSidFromProcessEXWorker(DWORD dwProcessId, PSID *ppSid)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        PRECONDITION(CheckPointer(ppSid));
-    }
-    CONTRACTL_END;
-
-    HRESULT            hr = S_OK;
-    PWTS_PROCESS_INFOW rgProcessInfo = NULL;
-    DWORD              dwNumProcesses;
-    DWORD              iProc;
-    DWORD              cbSid;
-    PSID               pSid = NULL;
-
-    LOG((LF_CORDB, LL_INFO10000,
-         "SecurityUtil::GetSidFromProcessEx: 0x%08x\n",
-         dwProcessId));
-
-
-    *ppSid = NULL;
-    if (!WTSEnumerateProcessesW(WTS_CURRENT_SERVER_HANDLE,   // use local server
-                                0,              // Reserved must be zero
-                                1,              // version must be 1
-                                &rgProcessInfo, // Receives pointer to process list
-                                &dwNumProcesses))
-    {
-        hr = HRESULT_FROM_GetLastError();
-        goto exit;
-    }
-
-    for (iProc = 0; iProc < dwNumProcesses; iProc++)
-    {
-
-        if (rgProcessInfo[iProc].ProcessId == dwProcessId)
-        {
-            if (rgProcessInfo[iProc].pUserSid == NULL)
-            {
-                LOG((LF_CORDB, LL_INFO10000,
-                     "SecurityUtil::GetSidFromProcessEx is not able to retrieve SID\n"));
-
-                // if there is no Sid for the user, don't call GetLengthSid.
-                // It will crash! It is ok to return E_FAIL as caller will ignore it.
-                hr = E_FAIL;
-                goto exit;
-            }
-            cbSid = GetLengthSid(rgProcessInfo[iProc].pUserSid);
-            pSid = new (nothrow) BYTE[cbSid];
-            if (pSid == NULL)
-            {
-                hr = E_OUTOFMEMORY;
-            }
-            else
-            {
-                if (!CopySid(cbSid, pSid, rgProcessInfo[iProc].pUserSid))
-                {
-                    hr = HRESULT_FROM_GetLastError();
-                }
-                else
-                {
-                    // We are done. Go to exit
-                    hr = S_OK;
-                }
-            }
-
-            // we already find a match. Even if we fail from memory allocation of CopySid, still
-            // goto exit.
-            goto exit;
-        }
-    }
-
-    // Walk the whole list and cannot find the matching PID
-    // Find a better error code.
-    hr = E_FAIL;
-
-exit:
-
-    if (rgProcessInfo)
-    {
-        WTSFreeMemory(rgProcessInfo);
-    }
-
-    if (FAILED(hr) && pSid)
-    {
-        delete [] (reinterpret_cast<BYTE*>(pSid));
-    }
-
-    if (SUCCEEDED(hr))
-    {
-        _ASSERTE(pSid);
-        *ppSid = pSid;
-    }
-    LOG((LF_CORDB, LL_INFO10000,
-         "SecurityUtil::GetSidFromProcessEx return hr : 0x%08x\n",
-         hr));
-
-
-    return hr;
-}
-#endif // !FEATURE_CORESYSTEM
-
 //-----------------------------------------------------------------------------
 // The functions below initialize this SidBuffer instance with a Sid from
 // the token of the specified process.  The first pair use the OWNER sid from
@@ -361,12 +250,6 @@ HRESULT SidBuffer::InitFromProcessNoThrow(DWORD pid)
 
     _ASSERTE(m_pBuffer == NULL);
     HRESULT hr = GetSidFromProcessWorker(pid, kOwnerSid, (PSID *) &m_pBuffer);
-#ifndef FEATURE_CORESYSTEM
-    if (FAILED(hr))
-    {
-        hr = GetSidFromProcessEXWorker(pid, (PSID *) &m_pBuffer);
-    }
-#endif // !FEATURE_CORESYSTEM
     if (FAILED(hr))
     {
         return hr;
@@ -526,12 +409,6 @@ HRESULT SidBuffer::InitFromProcessUserNoThrow(DWORD pid)
 
     _ASSERTE(m_pBuffer == NULL);
     HRESULT hr = GetSidFromProcessWorker(pid, kUserSid, (PSID *) &m_pBuffer);
-#ifndef FEATURE_CORESYSTEM
-    if (FAILED(hr))
-    {
-        hr = GetSidFromProcessEXWorker(pid, (PSID *) &m_pBuffer);
-    }
-#endif // !FEATURE_CORESYSTEM
     if (FAILED(hr))
     {
         return hr;
diff --git a/src/coreclr/utilcode/sstring.cpp b/src/coreclr/utilcode/sstring.cpp
index 6b5f7af901ac11..9ab6790efb3f60 100644
--- a/src/coreclr/utilcode/sstring.cpp
+++ b/src/coreclr/utilcode/sstring.cpp
@@ -2137,11 +2137,7 @@ void SString::PVPrintf(const WCHAR *format, va_list args)
     {
         // First, try to use the existing buffer
         va_copy(ap, args);
-#if defined(FEATURE_CORESYSTEM)
         int result = _vsnwprintf_s(GetRawUnicode(), GetRawCount()+1, _TRUNCATE, format, ap);
-#else
-        int result = _vswprintf_p(GetRawUnicode(), GetRawCount()+1, format, ap);
-#endif
         va_end(ap);
         if (result >= 0)
         {
@@ -2171,11 +2167,7 @@ void SString::PVPrintf(const WCHAR *format, va_list args)
         errno = 0;
 
         va_copy(ap, args);
-#if defined(FEATURE_CORESYSTEM)
         int result = _vsnwprintf_s(GetRawUnicode(), GetRawCount()+1, _TRUNCATE, format, ap);
-#else
-        int result = _vswprintf_p(GetRawUnicode(), GetRawCount()+1, format, ap);
-#endif
         va_end(ap);
 
         if (result >= 0)
diff --git a/src/coreclr/utilcode/util.cpp b/src/coreclr/utilcode/util.cpp
index bf31761902dcef..ee90f9db6c538a 100644
--- a/src/coreclr/utilcode/util.cpp
+++ b/src/coreclr/utilcode/util.cpp
@@ -25,61 +25,6 @@
 UINT32 g_nClrInstanceId = 0;
 #endif //!DACCESS_COMPILE
 
-//********** Code. ************************************************************
-
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORESYSTEM)
-extern WinRTStatusEnum gWinRTStatus = WINRT_STATUS_UNINITED;
-#endif // FEATURE_COMINTEROP && !FEATURE_CORESYSTEM
-
-#if defined(FEATURE_COMINTEROP) && !defined(FEATURE_CORESYSTEM)
-//------------------------------------------------------------------------------
-//
-// Attempt to detect the presense of Windows Runtime support on the current OS.
-// Our algorithm to do this is to ensure that:
-//      1. combase.dll exists
-//      2. combase.dll contains a RoInitialize export
-//
-
-void InitWinRTStatus()
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_CANNOT_TAKE_LOCK;
-
-    WinRTStatusEnum winRTStatus = WINRT_STATUS_UNSUPPORTED;
-
-    const WCHAR wszComBaseDll[] = W("\\combase.dll");
-    const SIZE_T cchComBaseDll = ARRAY_SIZE(wszComBaseDll);
-
-    WCHAR wszComBasePath[MAX_LONGPATH + 1];
-    const SIZE_T cchComBasePath = ARRAY_SIZE(wszComBasePath);
-
-    ZeroMemory(wszComBasePath, cchComBasePath * sizeof(wszComBasePath[0]));
-
-    UINT cchSystemDirectory = WszGetSystemDirectory(wszComBasePath, MAX_LONGPATH);
-
-    // Make sure that we're only probing in the system directory.  If we can't find the system directory, or
-    // we find it but combase.dll doesn't fit into it, we'll fall back to a safe default of saying that WinRT
-    // is simply not present.
-    if (cchSystemDirectory > 0 && cchComBasePath - cchSystemDirectory >= cchComBaseDll)
-    {
-        if (wcscat_s(wszComBasePath, wszComBaseDll) == 0)
-        {
-            HModuleHolder hComBase(WszLoadLibrary(wszComBasePath));
-            if (hComBase != NULL)
-            {
-                FARPROC activateInstace = GetProcAddress(hComBase, "RoInitialize");
-                if (activateInstace != NULL)
-                {
-                    winRTStatus = WINRT_STATUS_SUPPORTED;
-                }
-            }
-        }
-    }
-
-    gWinRTStatus = winRTStatus;
-}
-#endif // FEATURE_COMINTEROP && !FEATURE_CORESYSTEM
 //*****************************************************************************
 // Convert a string of hex digits into a hex value of the specified # of bytes.
 //*****************************************************************************
diff --git a/src/coreclr/utilcode/utilmessagebox.cpp b/src/coreclr/utilcode/utilmessagebox.cpp
index 5a8b1f5e2d69b8..8ae1d046169e78 100644
--- a/src/coreclr/utilcode/utilmessagebox.cpp
+++ b/src/coreclr/utilcode/utilmessagebox.cpp
@@ -17,12 +17,6 @@
 #include "clrversion.h"
 #include "../dlls/mscorrc/resource.h"
 #include "ex.h"
-#if !defined(FEATURE_CORESYSTEM)
-#undef NTDDI_VERSION
-#define NTDDI_VERSION NTDDI_WIN7
-#include "commctrl.h"
-#endif
-
 
 BOOL ShouldDisplayMsgBoxOnCriticalFailure()
 {
@@ -193,48 +187,46 @@ int UtilMessageBoxNonLocalizedVA(
         }
 
 #if !defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
-        // If the current process isn't interactive (a service for example), then we report the message
-        // in the event log and via OutputDebugString.
+#ifdef HOST_UNIX
+        // For non-interactive processes, we report the message in the event log and via OutputDebugString.
         //
         // We may still however attempt to display the message box if the MB_SERVICE_NOTIFICATION
         // message box style was specified.
-        if (!RunningInteractive())
+        StackSString message;
+
+        message.Printf(W(".NET Runtime version : %s - "), CLR_PRODUCT_VERSION_L);
+        if (lpTitle)
+            message.Append(lpTitle);
+        if (!formattedMessage.IsEmpty())
+            message.Append(formattedMessage);
+
+        ClrReportEvent(W(".NET Runtime"),
+            EVENTLOG_ERROR_TYPE,    // event type
+            0,                      // category zero
+            1024,                   // event identifier
+            NULL,                   // no user security identifier
+            message.GetUnicode());
+
+        if(lpTitle != NULL)
+            WszOutputDebugString(lpTitle);
+        if(!formattedMessage.IsEmpty())
+            WszOutputDebugString(formattedMessage);
+
+        // If we are running as a service and displayForNonInteractive is FALSE then IDABORT is
+        // the best value to return as it will most likely cause callers of this API to abort the process.
+        // This is the right thing to do since attaching a debugger doesn't make much sense when the process isn't
+        // running in interactive mode.
+        if(!displayForNonInteractive)
         {
-            StackSString message;
-
-            message.Printf(W(".NET Runtime version : %s - "), CLR_PRODUCT_VERSION_L);
-            if (lpTitle)
-                message.Append(lpTitle);
-            if (!formattedMessage.IsEmpty())
-                message.Append(formattedMessage);
-
-            ClrReportEvent(W(".NET Runtime"),
-                EVENTLOG_ERROR_TYPE,    // event type
-                0,                      // category zero
-                1024,                   // event identifier
-                NULL,                   // no user security identifier
-                message.GetUnicode());
-
-            if(lpTitle != NULL)
-                WszOutputDebugString(lpTitle);
-            if(!formattedMessage.IsEmpty())
-                WszOutputDebugString(formattedMessage);
-
-            // If we are running as a service and displayForNonInteractive is FALSE then IDABORT is
-            // the best value to return as it will most likely cause callers of this API to abort the process.
-            // This is the right thing to do since attaching a debugger doesn't make much sense when the process isn't
-            // running in interactive mode.
-            if(!displayForNonInteractive)
-            {
-                fDisplayMsgBox = FALSE;
-                result = IDABORT;
-            }
-            else
-            {
-                // Include in the MB_DEFAULT_DESKTOP_ONLY style.
-                uType |= MB_DEFAULT_DESKTOP_ONLY;
-            }
+            fDisplayMsgBox = FALSE;
+            result = IDABORT;
+        }
+        else
+        {
+            // Include in the MB_DEFAULT_DESKTOP_ONLY style.
+            uType |= MB_DEFAULT_DESKTOP_ONLY;
         }
+#endif // HOST_UNIX
 #endif //!defined(FEATURE_UTILCODE_NO_DEPENDENCIES)
 
         if (fDisplayMsgBox)
diff --git a/src/coreclr/utilcode/winfix.cpp b/src/coreclr/utilcode/winfix.cpp
index d572c8edb26ef6..c6733767e77bf3 100644
--- a/src/coreclr/utilcode/winfix.cpp
+++ b/src/coreclr/utilcode/winfix.cpp
@@ -217,39 +217,6 @@ void EnsureCharSetInfoInitialized()
     return;
 }
 
-
-// Running with an interactive workstation.
-BOOL RunningInteractive()
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_FORBID_FAULT;
-
-    static int fInteractive = -1;
-    if (fInteractive != -1)
-        return fInteractive != 0;
-
-#if !defined(FEATURE_CORESYSTEM)
-        HWINSTA hwinsta = NULL;
-
-        if ((hwinsta = GetProcessWindowStation() ) != NULL)
-        {
-            DWORD lengthNeeded;
-            USEROBJECTFLAGS flags;
-
-            if (GetUserObjectInformationW (hwinsta, UOI_FLAGS, &flags, sizeof(flags), &lengthNeeded))
-           {
-                    if ((flags.dwFlags & WSF_VISIBLE) == 0)
-                        fInteractive = 0;
-            }
-        }
-#endif // !FEATURE_CORESYSTEM
-
-    if (fInteractive != 0)
-        fInteractive = 1;
-
-    return fInteractive != 0;
-}
-
 typedef HRESULT(WINAPI *pfnSetThreadDescription)(HANDLE hThread, PCWSTR lpThreadDescription);
 extern pfnSetThreadDescription g_pfnSetThreadDescription;
 
diff --git a/src/coreclr/vm/.vscode/c_cpp_properties.json b/src/coreclr/vm/.vscode/c_cpp_properties.json
index 3e0fa37196a654..16279d8db9e741 100644
--- a/src/coreclr/vm/.vscode/c_cpp_properties.json
+++ b/src/coreclr/vm/.vscode/c_cpp_properties.json
@@ -50,7 +50,6 @@
                 "FEATURE_COMINTEROP_UNMANAGED_ACTIVATION",
                 "FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION",
                 "FEATURE_CORECLR",
-                "FEATURE_CORESYSTEM",
                 "FEATURE_DATABREAKPOINT",
                 "FEATURE_DEFAULT_INTERFACES",
                 "FEATURE_EVENT_TRACE=1",
diff --git a/src/coreclr/vm/dwreport.cpp b/src/coreclr/vm/dwreport.cpp
index 1032725eb854b3..47defdeedb5d0d 100644
--- a/src/coreclr/vm/dwreport.cpp
+++ b/src/coreclr/vm/dwreport.cpp
@@ -17,6 +17,7 @@
 #include "field.h"
 #include <msodwwrap.h>
 #include <shlobj.h>
+#include <werapi.h>
 #include "dbginterface.h"
 #include <winver.h>
 #include "dlwrap.h"
@@ -57,14 +58,6 @@ class SimpleModuleHolder
     operator HMODULE() { return hModule; }
 };
 
-#ifndef FEATURE_CORESYSTEM
-#define WER_MODULE_NAME_W WINDOWS_KERNEL32_DLLNAME_W
-typedef SimpleModuleHolder<WszGetModuleHandle, false> WerModuleHolder;
-#else
-#define WER_MODULE_NAME_W W("api-ms-win-core-windowserrorreporting-l1-1-0.dll")
-typedef SimpleModuleHolder<CLRLoadLibrary, true> WerModuleHolder;
-#endif
-
 //------------------------------------------------------------------------------
 // Description
 //  Indicate if Watson is enabled
@@ -107,47 +100,17 @@ BOOL RegisterOutOfProcessWatsonCallbacks()
     CONTRACTL_END;
 
     WCHAR wszDACName[] = MAIN_DAC_MODULE_NAME_W W(".dll");
-    WerModuleHolder hWerModule(WER_MODULE_NAME_W);
-
-#ifdef FEATURE_CORESYSTEM
-    if ((hWerModule == NULL) && !RunningOnWin8())
-    {
-        // If we are built for CoreSystemServer, but are running on Windows 7, we need to look elsewhere
-        hWerModule = WerModuleHolder(W("Kernel32.dll"));
-    }
-#endif
-
-    if (hWerModule == NULL)
-    {
-        _ASSERTE(!"failed to get WER module handle");
-        return FALSE;
-    }
-
-    typedef HRESULT (WINAPI * WerRegisterRuntimeExceptionModuleFnPtr)(PCWSTR, PDWORD);
-    WerRegisterRuntimeExceptionModuleFnPtr pFnWerRegisterRuntimeExceptionModule;
-
-    pFnWerRegisterRuntimeExceptionModule = (WerRegisterRuntimeExceptionModuleFnPtr)
-                                        GetProcAddress(hWerModule, "WerRegisterRuntimeExceptionModule");
-
-    _ASSERTE(pFnWerRegisterRuntimeExceptionModule != NULL);
-    if (pFnWerRegisterRuntimeExceptionModule == NULL)
-    {
-       return FALSE;
-    }
     HRESULT hr = S_OK;
 
     EX_TRY
     {
         PathString wszDACPath;
-        if (SUCCEEDED(::GetClrModuleDirectory(wszDACPath)))
+        hr = ::GetClrModuleDirectory(wszDACPath);
+        if (SUCCEEDED(hr))
         {
             wszDACPath.Append(wszDACName);
-            hr = (*pFnWerRegisterRuntimeExceptionModule)(wszDACPath, (PDWORD)GetClrModuleBase());
-        }
-        else {
-            hr = E_FAIL;
+            hr = WerRegisterRuntimeExceptionModule(wszDACPath, (PDWORD)GetClrModuleBase());
         }
-
     }
     EX_CATCH_HRESULT(hr);
 
@@ -156,16 +119,7 @@ BOOL RegisterOutOfProcessWatsonCallbacks()
         STRESS_LOG0(LF_STARTUP,
                     LL_ERROR,
                     "WATSON support: failed to register DAC dll with WerRegisterRuntimeExceptionModule");
-
-#ifdef FEATURE_CORESYSTEM
-        // For CoreSys we *could* be running on a platform that doesn't have Watson proper
-        // (the APIs might exist but they just fail).
-        // WerRegisterRuntimeExceptionModule may return E_NOIMPL.
         return TRUE;
-#else // FEATURE_CORESYSTEM
-       _ASSERTE(! "WATSON support: failed to register DAC dll with WerRegisterRuntimeExceptionModule");
-        return FALSE;
-#endif // FEATURE_CORESYSTEM
     }
 
     STRESS_LOG0(LF_STARTUP,
diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp
index 109f98ceecfe13..46669283188b9e 100644
--- a/src/coreclr/vm/jithelpers.cpp
+++ b/src/coreclr/vm/jithelpers.cpp
@@ -529,16 +529,8 @@ ftype BankersRound(ftype value)
     if ((value -(integerPart +0.5)) == 0.0)
     {
         // round to even
-#if defined(TARGET_ARM) && defined(FEATURE_CORESYSTEM)
-        // @ARMTODO: On ARM when building on CoreSystem (where we link against the system CRT) an attempt to
-        // use fmod(float, float) fails to link (apparently this is converted to a reference to fmodf, which
-        // is not included in the system CRT). Use the double version instead.
-        if (fmod(double(integerPart), double(2.0)) == 0.0)
-            return integerPart;
-#else
         if (fmod(ftype(integerPart), ftype(2.0)) == 0.0)
             return integerPart;
-#endif
 
         // Else return the nearest even integer
         return (ftype)_copysign(ceil(fabs(value+0.5)),
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
index f02693ae034219..5625deef44c0dc 100644
--- a/src/coreclr/vm/jitinterface.cpp
+++ b/src/coreclr/vm/jitinterface.cpp
@@ -12815,13 +12815,11 @@ PCODE UnsafeJitFunction(PrepareCodeConfig* config,
             "Jitted Entry at" FMT_ADDR "method %s::%s %s\n", DBG_ADDR(nativeEntry),
              ftn->m_pszDebugClassName, ftn->m_pszDebugMethodName, ftn->m_pszDebugMethodSignature));
 
-#if defined(FEATURE_CORESYSTEM)
-
 #ifdef _DEBUG
         LPCUTF8 pszDebugClassName = ftn->m_pszDebugClassName;
         LPCUTF8 pszDebugMethodName = ftn->m_pszDebugMethodName;
         LPCUTF8 pszDebugMethodSignature = ftn->m_pszDebugMethodSignature;
-#else
+#elif 0
         LPCUTF8 pszNamespace;
         LPCUTF8 pszDebugClassName = ftn->GetMethodTable()->GetFullyQualifiedNameInfo(&pszNamespace);
         LPCUTF8 pszDebugMethodName = ftn->GetName();
@@ -12830,7 +12828,6 @@ PCODE UnsafeJitFunction(PrepareCodeConfig* config,
 
         //DbgPrintf("Jitted Entry at" FMT_ADDR "method %s::%s %s size %08x\n", DBG_ADDR(nativeEntry),
         //          pszDebugClassName, pszDebugMethodName, pszDebugMethodSignature, sizeOfCode);
-#endif
 
         ClrFlushInstructionCache(nativeEntry, sizeOfCode);
         ret = (PCODE)nativeEntry;
diff --git a/src/coreclr/vm/nativelibrary.cpp b/src/coreclr/vm/nativelibrary.cpp
index d5a91b4863c2fc..9be259ec200d8c 100644
--- a/src/coreclr/vm/nativelibrary.cpp
+++ b/src/coreclr/vm/nativelibrary.cpp
@@ -610,7 +610,7 @@ namespace
 
         NATIVE_LIBRARY_HANDLE hmod = NULL;
 
-#if defined(FEATURE_CORESYSTEM) && !defined(TARGET_UNIX)
+#if !defined(TARGET_UNIX)
         // Try to go straight to System32 for Windows API sets. This is replicating quick check from
         // the OS implementation of api sets.
         if (IsWindowsAPISet(wszLibName))
@@ -621,7 +621,7 @@ namespace
                 return hmod;
             }
         }
-#endif // FEATURE_CORESYSTEM && !TARGET_UNIX
+#endif // !TARGET_UNIX
 
         if (g_hostpolicy_embedded)
         {
diff --git a/src/coreclr/vm/util.cpp b/src/coreclr/vm/util.cpp
index 026ba5da743a56..12a4ed3225739a 100644
--- a/src/coreclr/vm/util.cpp
+++ b/src/coreclr/vm/util.cpp
@@ -329,22 +329,6 @@ void NPrintToHandleA(HANDLE Handle, const char *pszString, size_t BytesToWrite)
 
     while (BytesToWrite > 0) {
         DWORD dwChunkToWrite = (DWORD) min(BytesToWrite, maxWriteFileSize);
-        // No CharNextExA on CoreSystem, we just assume no multi-byte characters (this code path shouldn't be
-        // used in the production codepath for currently supported CoreSystem based products anyway).
-#ifndef FEATURE_CORESYSTEM
-        if (dwChunkToWrite < BytesToWrite) {
-            break;
-            // must go by char to find biggest string that will fit, taking DBCS chars into account
-            //dwChunkToWrite = 0;
-            //const char *charNext = pszString;
-            //while (dwChunkToWrite < maxWriteFileSize-2 && charNext) {
-            //    charNext = CharNextExA(0, pszString+dwChunkToWrite, 0);
-            //    dwChunkToWrite = (DWORD)(charNext - pszString);
-            //}
-            //if (dwChunkToWrite == 0)
-            //    break;
-        }
-#endif // !FEATURE_CORESYSTEM
 
         // Try to write to handle.  If this is not a CUI app, then this is probably
         // not going to work unless the dev took special pains to set their own console
diff --git a/src/coreclr/vm/win32threadpool.cpp b/src/coreclr/vm/win32threadpool.cpp
index 7ffbc34948a471..3e16f18a2d83b9 100644
--- a/src/coreclr/vm/win32threadpool.cpp
+++ b/src/coreclr/vm/win32threadpool.cpp
@@ -494,11 +494,7 @@ void ThreadpoolMgr::InitPlatformVariables()
         _ASSERTE(hNtDll);
         if (!UsePortableThreadPool())
         {
-#ifdef FEATURE_CORESYSTEM
             hCoreSynch = CLRLoadLibrary(W("api-ms-win-core-synch-l1-1-0.dll"));
-#else
-            hCoreSynch = CLRLoadLibrary(W("kernel32.dll"));
-#endif
             _ASSERTE(hCoreSynch);
         }
     }
@@ -3999,7 +3995,7 @@ DWORD WINAPI ThreadpoolMgr::GateThreadStart(LPVOID lpArgs)
      * 2. GCCpuGroups=1, CLR creates GC threads for all processors in all CPU groups
      *    thus, the threadpool thread would use a whole CPU group (if Thread_UseAllCpuGroups is not set).
      *    ==> use g_SystemInfo.dwNumberOfProcessors.
-     * 3. !defined(TARGET_UNIX) but defined(FEATURE_CORESYSTEM), GetCurrentProcessCpuCount()
+     * 3. !defined(TARGET_UNIX), GetCurrentProcessCpuCount()
      *    returns g_SystemInfo.dwNumberOfProcessors ==> use g_SystemInfo.dwNumberOfProcessors;
      * Other cases:
      * 1. Normal case: the mask is all or a subset of all processors in a CPU group;

From 93497f3756d7228dece0a945fa77a374f9caebd5 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Wed, 26 Jan 2022 19:23:44 +0100
Subject: [PATCH 090/161] [main] Update dependencies from dotnet/arcade
 dotnet/runtime-assets (#64331)

* Update dependencies from https://github.com/dotnet/arcade build 20220125.6

Microsoft.DotNet.XUnitConsoleRunner , Microsoft.DotNet.CodeAnalysis , Microsoft.DotNet.Build.Tasks.Workloads , Microsoft.DotNet.Build.Tasks.Templating , Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk , Microsoft.DotNet.Build.Tasks.Packaging , Microsoft.DotNet.Build.Tasks.Installers , Microsoft.DotNet.Build.Tasks.Feed , Microsoft.DotNet.Build.Tasks.Archives , Microsoft.DotNet.Arcade.Sdk , Microsoft.DotNet.ApiCompat , Microsoft.DotNet.XUnitExtensions , Microsoft.DotNet.GenAPI , Microsoft.DotNet.VersionTools.Tasks , Microsoft.DotNet.GenFacades , Microsoft.DotNet.SharedFramework.Sdk , Microsoft.DotNet.RemoteExecutor , Microsoft.DotNet.PackageTesting , Microsoft.DotNet.Helix.Sdk
 From Version 2.5.1-beta.22074.13 -> To Version 2.5.1-beta.22075.6

* Update dependencies from https://github.com/dotnet/runtime-assets build 20220125.1

Microsoft.DotNet.CilStrip.Sources , System.ComponentModel.TypeConverter.TestData , System.Drawing.Common.TestData , System.IO.Compression.TestData , System.IO.Packaging.TestData , System.Net.TestData , System.Private.Runtime.UnicodeData , System.Runtime.Numerics.TestData , System.Runtime.TimeZoneData , System.Security.Cryptography.X509Certificates.TestData , System.Text.RegularExpressions.TestData , System.Windows.Extensions.TestData
 From Version 7.0.0-beta.22060.1 -> To Version 7.0.0-beta.22075.1

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
---
 eng/Version.Details.xml          | 124 +++++++++++++++----------------
 eng/Versions.props               |  54 +++++++-------
 eng/common/cross/build-rootfs.sh |  12 +--
 global.json                      |   8 +-
 4 files changed, 97 insertions(+), 101 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 0e09fa1f297b36..3da43d2ed21e24 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -50,125 +50,125 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.ApiCompat" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenAPI" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.GenAPI" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenFacades" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.GenFacades" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.XUnitConsoleRunner" Version="2.5.1-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Archives" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Packaging" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Templating" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Templating" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Workloads" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Workloads" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.CodeAnalysis" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Feed" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.VersionTools.Tasks" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.SharedFramework.Sdk" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NET.Test.Sdk" Version="16.9.0-preview-20201201-01">
       <Uri>https://github.com/microsoft/vstest</Uri>
       <Sha>140434f7109d357d0158ade9e5164a4861513965</Sha>
     </Dependency>
-    <Dependency Name="System.ComponentModel.TypeConverter.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.ComponentModel.TypeConverter.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.Drawing.Common.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Drawing.Common.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.IO.Compression.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.IO.Compression.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.IO.Packaging.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.IO.Packaging.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.Net.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Net.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.Private.Runtime.UnicodeData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Private.Runtime.UnicodeData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.Runtime.TimeZoneData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Runtime.TimeZoneData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.Security.Cryptography.X509Certificates.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Security.Cryptography.X509Certificates.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.Text.RegularExpressions.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Text.RegularExpressions.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="System.Windows.Extensions.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Windows.Extensions.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.CilStrip.Sources" Version="7.0.0-beta.22060.1">
+    <Dependency Name="Microsoft.DotNet.CilStrip.Sources" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
     <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="11.1.0-alpha.1.22074.2">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
@@ -250,9 +250,9 @@
       <Uri>https://github.com/dotnet/xharness</Uri>
       <Sha>0137095821e2e5a9e030d97248503387b8d72a18</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="7.0.0-beta.22074.13">
+    <Dependency Name="Microsoft.DotNet.PackageTesting" Version="7.0.0-beta.22075.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>b6483cac5832aa5207692517f9a49ce1741a3041</Sha>
+      <Sha>86a931a4ebfa4d65630f0ff6cedf787d2e48a3b9</Sha>
     </Dependency>
     <Dependency Name="optimization.windows_nt-x64.MIBC.Runtime" Version="1.0.0-prerelease.21577.2">
       <Uri>https://dev.azure.com/dnceng/internal/_git/dotnet-optimization</Uri>
@@ -274,9 +274,9 @@
       <Uri>https://github.com/dotnet/hotreload-utils</Uri>
       <Sha>d3e96c2e8ed4d58de217c44423c9ba3b90333724</Sha>
     </Dependency>
-    <Dependency Name="System.Runtime.Numerics.TestData" Version="7.0.0-beta.22060.1">
+    <Dependency Name="System.Runtime.Numerics.TestData" Version="7.0.0-beta.22075.1">
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
-      <Sha>a597df23119faf540d95cebab14b82f084c47384</Sha>
+      <Sha>8813c6d9e73b5cb0b4ccf4c0b8c609ad344636a7</Sha>
     </Dependency>
     <Dependency Name="Microsoft.CodeAnalysis.NetAnalyzers" Version="7.0.0-preview1.22068.2">
       <Uri>https://github.com/dotnet/roslyn-analyzers</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 5beaf9c02f194a..aae2d08e090181 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -54,21 +54,21 @@
     <!-- SDK dependencies -->
     <MicrosoftDotNetCompatibilityVersion>2.0.0-alpha.1.21525.11</MicrosoftDotNetCompatibilityVersion>
     <!-- Arcade dependencies -->
-    <MicrosoftDotNetApiCompatVersion>7.0.0-beta.22074.13</MicrosoftDotNetApiCompatVersion>
-    <MicrosoftDotNetBuildTasksFeedVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksFeedVersion>
-    <MicrosoftDotNetCodeAnalysisVersion>7.0.0-beta.22074.13</MicrosoftDotNetCodeAnalysisVersion>
-    <MicrosoftDotNetGenAPIVersion>7.0.0-beta.22074.13</MicrosoftDotNetGenAPIVersion>
-    <MicrosoftDotNetGenFacadesVersion>7.0.0-beta.22074.13</MicrosoftDotNetGenFacadesVersion>
-    <MicrosoftDotNetXUnitExtensionsVersion>7.0.0-beta.22074.13</MicrosoftDotNetXUnitExtensionsVersion>
-    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.22074.13</MicrosoftDotNetXUnitConsoleRunnerVersion>
-    <MicrosoftDotNetBuildTasksArchivesVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksArchivesVersion>
-    <MicrosoftDotNetBuildTasksInstallersVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksInstallersVersion>
-    <MicrosoftDotNetBuildTasksPackagingVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksPackagingVersion>
-    <MicrosoftDotNetBuildTasksTemplatingVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksTemplatingVersion>
-    <MicrosoftDotNetBuildTasksWorkloadsPackageVersion>7.0.0-beta.22074.13</MicrosoftDotNetBuildTasksWorkloadsPackageVersion>
-    <MicrosoftDotNetRemoteExecutorVersion>7.0.0-beta.22074.13</MicrosoftDotNetRemoteExecutorVersion>
-    <MicrosoftDotNetVersionToolsTasksVersion>7.0.0-beta.22074.13</MicrosoftDotNetVersionToolsTasksVersion>
-    <MicrosoftDotNetPackageTestingVersion>7.0.0-beta.22074.13</MicrosoftDotNetPackageTestingVersion>
+    <MicrosoftDotNetApiCompatVersion>7.0.0-beta.22075.6</MicrosoftDotNetApiCompatVersion>
+    <MicrosoftDotNetBuildTasksFeedVersion>7.0.0-beta.22075.6</MicrosoftDotNetBuildTasksFeedVersion>
+    <MicrosoftDotNetCodeAnalysisVersion>7.0.0-beta.22075.6</MicrosoftDotNetCodeAnalysisVersion>
+    <MicrosoftDotNetGenAPIVersion>7.0.0-beta.22075.6</MicrosoftDotNetGenAPIVersion>
+    <MicrosoftDotNetGenFacadesVersion>7.0.0-beta.22075.6</MicrosoftDotNetGenFacadesVersion>
+    <MicrosoftDotNetXUnitExtensionsVersion>7.0.0-beta.22075.6</MicrosoftDotNetXUnitExtensionsVersion>
+    <MicrosoftDotNetXUnitConsoleRunnerVersion>2.5.1-beta.22075.6</MicrosoftDotNetXUnitConsoleRunnerVersion>
+    <MicrosoftDotNetBuildTasksArchivesVersion>7.0.0-beta.22075.6</MicrosoftDotNetBuildTasksArchivesVersion>
+    <MicrosoftDotNetBuildTasksInstallersVersion>7.0.0-beta.22075.6</MicrosoftDotNetBuildTasksInstallersVersion>
+    <MicrosoftDotNetBuildTasksPackagingVersion>7.0.0-beta.22075.6</MicrosoftDotNetBuildTasksPackagingVersion>
+    <MicrosoftDotNetBuildTasksTemplatingVersion>7.0.0-beta.22075.6</MicrosoftDotNetBuildTasksTemplatingVersion>
+    <MicrosoftDotNetBuildTasksWorkloadsPackageVersion>7.0.0-beta.22075.6</MicrosoftDotNetBuildTasksWorkloadsPackageVersion>
+    <MicrosoftDotNetRemoteExecutorVersion>7.0.0-beta.22075.6</MicrosoftDotNetRemoteExecutorVersion>
+    <MicrosoftDotNetVersionToolsTasksVersion>7.0.0-beta.22075.6</MicrosoftDotNetVersionToolsTasksVersion>
+    <MicrosoftDotNetPackageTestingVersion>7.0.0-beta.22075.6</MicrosoftDotNetPackageTestingVersion>
     <!-- NuGet dependencies -->
     <NuGetBuildTasksPackVersion>6.0.0-preview.1.102</NuGetBuildTasksPackVersion>
     <!-- Installer dependencies -->
@@ -126,18 +126,18 @@
     <SystemValueTupleVersion>4.5.0</SystemValueTupleVersion>
     <runtimenativeSystemIOPortsVersion>7.0.0-alpha.1.22073.5</runtimenativeSystemIOPortsVersion>
     <!-- Runtime-Assets dependencies -->
-    <SystemRuntimeNumericsTestDataVersion>7.0.0-beta.22060.1</SystemRuntimeNumericsTestDataVersion>
-    <SystemComponentModelTypeConverterTestDataVersion>7.0.0-beta.22060.1</SystemComponentModelTypeConverterTestDataVersion>
-    <SystemDrawingCommonTestDataVersion>7.0.0-beta.22060.1</SystemDrawingCommonTestDataVersion>
-    <SystemIOCompressionTestDataVersion>7.0.0-beta.22060.1</SystemIOCompressionTestDataVersion>
-    <SystemIOPackagingTestDataVersion>7.0.0-beta.22060.1</SystemIOPackagingTestDataVersion>
-    <SystemNetTestDataVersion>7.0.0-beta.22060.1</SystemNetTestDataVersion>
-    <SystemPrivateRuntimeUnicodeDataVersion>7.0.0-beta.22060.1</SystemPrivateRuntimeUnicodeDataVersion>
-    <SystemRuntimeTimeZoneDataVersion>7.0.0-beta.22060.1</SystemRuntimeTimeZoneDataVersion>
-    <SystemSecurityCryptographyX509CertificatesTestDataVersion>7.0.0-beta.22060.1</SystemSecurityCryptographyX509CertificatesTestDataVersion>
-    <SystemTextRegularExpressionsTestDataVersion>7.0.0-beta.22060.1</SystemTextRegularExpressionsTestDataVersion>
-    <SystemWindowsExtensionsTestDataVersion>7.0.0-beta.22060.1</SystemWindowsExtensionsTestDataVersion>
-    <MicrosoftDotNetCilStripSourcesVersion>7.0.0-beta.22060.1</MicrosoftDotNetCilStripSourcesVersion>
+    <SystemRuntimeNumericsTestDataVersion>7.0.0-beta.22075.1</SystemRuntimeNumericsTestDataVersion>
+    <SystemComponentModelTypeConverterTestDataVersion>7.0.0-beta.22075.1</SystemComponentModelTypeConverterTestDataVersion>
+    <SystemDrawingCommonTestDataVersion>7.0.0-beta.22075.1</SystemDrawingCommonTestDataVersion>
+    <SystemIOCompressionTestDataVersion>7.0.0-beta.22075.1</SystemIOCompressionTestDataVersion>
+    <SystemIOPackagingTestDataVersion>7.0.0-beta.22075.1</SystemIOPackagingTestDataVersion>
+    <SystemNetTestDataVersion>7.0.0-beta.22075.1</SystemNetTestDataVersion>
+    <SystemPrivateRuntimeUnicodeDataVersion>7.0.0-beta.22075.1</SystemPrivateRuntimeUnicodeDataVersion>
+    <SystemRuntimeTimeZoneDataVersion>7.0.0-beta.22075.1</SystemRuntimeTimeZoneDataVersion>
+    <SystemSecurityCryptographyX509CertificatesTestDataVersion>7.0.0-beta.22075.1</SystemSecurityCryptographyX509CertificatesTestDataVersion>
+    <SystemTextRegularExpressionsTestDataVersion>7.0.0-beta.22075.1</SystemTextRegularExpressionsTestDataVersion>
+    <SystemWindowsExtensionsTestDataVersion>7.0.0-beta.22075.1</SystemWindowsExtensionsTestDataVersion>
+    <MicrosoftDotNetCilStripSourcesVersion>7.0.0-beta.22075.1</MicrosoftDotNetCilStripSourcesVersion>
     <!-- dotnet-optimization dependencies -->
     <optimizationwindows_ntx64MIBCRuntimeVersion>1.0.0-prerelease.21577.2</optimizationwindows_ntx64MIBCRuntimeVersion>
     <optimizationwindows_ntx86MIBCRuntimeVersion>1.0.0-prerelease.21577.2</optimizationwindows_ntx86MIBCRuntimeVersion>
diff --git a/eng/common/cross/build-rootfs.sh b/eng/common/cross/build-rootfs.sh
index e94d13d62ef64d..f97dca77054089 100755
--- a/eng/common/cross/build-rootfs.sh
+++ b/eng/common/cross/build-rootfs.sh
@@ -7,7 +7,7 @@ usage()
     echo "Usage: $0 [BuildArch] [CodeName] [lldbx.y] [--skipunmount] --rootfsdir <directory>]"
     echo "BuildArch can be: arm(default), armel, arm64, x86"
     echo "CodeName - optional, Code name for Linux, can be: xenial(default), zesty, bionic, alpine, alpine3.13 or alpine3.14. If BuildArch is armel, LinuxCodeName is jessie(default) or tizen."
-    echo "                              for FreeBSD can be: freebsd11, freebsd12, freebsd13"
+    echo "                              for FreeBSD can be: freebsd12, freebsd13"
     echo "                              for illumos can be: illumos."
     echo "lldbx.y - optional, LLDB version, can be: lldb3.9(default), lldb4.0, lldb5.0, lldb6.0 no-lldb. Ignored for alpine and FreeBSD"
     echo "--skipunmount - optional, will skip the unmount of rootfs folder."
@@ -60,13 +60,13 @@ __AlpinePackages+=" krb5-dev"
 __AlpinePackages+=" openssl-dev"
 __AlpinePackages+=" zlib-dev"
 
-__FreeBSDBase="12.2-RELEASE"
-__FreeBSDPkg="1.12.0"
+__FreeBSDBase="12.3-RELEASE"
+__FreeBSDPkg="1.17.0"
 __FreeBSDABI="12"
 __FreeBSDPackages="libunwind"
 __FreeBSDPackages+=" icu"
 __FreeBSDPackages+=" libinotify"
-__FreeBSDPackages+=" lttng-ust"
+__FreeBSDPackages+=" openssl"
 __FreeBSDPackages+=" krb5"
 __FreeBSDPackages+=" terminfo-db"
 
@@ -206,10 +206,6 @@ while :; do
             __AlpineVersion=3.14
             __AlpinePackages+=" llvm11-libs"
             ;;
-        freebsd11)
-            __FreeBSDBase="11.3-RELEASE"
-            __FreeBSDABI="11"
-            ;&
         freebsd12)
             __CodeName=freebsd
             __BuildArch=x64
diff --git a/global.json b/global.json
index c6832999bdb02a..43ff763c74d864 100644
--- a/global.json
+++ b/global.json
@@ -12,10 +12,10 @@
     "python3": "3.7.1"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "7.0.0-beta.22074.13",
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22074.13",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22074.13",
-    "Microsoft.DotNet.SharedFramework.Sdk": "7.0.0-beta.22074.13",
+    "Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk": "7.0.0-beta.22075.6",
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22075.6",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22075.6",
+    "Microsoft.DotNet.SharedFramework.Sdk": "7.0.0-beta.22075.6",
     "Microsoft.Build.NoTargets": "3.1.0",
     "Microsoft.Build.Traversal": "3.0.23",
     "Microsoft.NET.Sdk.IL": "7.0.0-alpha.1.22073.5"

From 24df302b2abbb6ae29930348f65c87bf82d4a02c Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <maryam.ariyan@microsoft.com>
Date: Wed, 26 Jan 2022 11:18:19 -0800
Subject: [PATCH 091/161] Fixes bad log method generation in certain cases.
 (#64311)

In certain cases when developer by mistake places ILogger, Exception, or LogLevel in the message template,  the code generator will produce the expected warning and makes sure the code will indeed compile and run correctly.

Prior to this fix, the code generator would fail to compile with when either of ILogger, Exception or LogLevel were placed in message template incorrectly.

Fixes #64310
---
 .../gen/LoggerMessageGenerator.Parser.cs      |  6 +++++-
 .../LoggerMessageGeneratedCodeTests.cs        | 21 +++++++++++++++++++
 .../LoggerMessageGeneratorEmitterTests.cs     |  2 +-
 .../LoggerMessageGeneratorParserTests.cs      | 12 +++++++++--
 ...ExceptionTestExtensions.WithDiagnostics.cs | 15 +++++++++++++
 .../LevelTestExtensions.WithDiagnostics.cs    | 18 ++++++++++++++++
 6 files changed, 70 insertions(+), 4 deletions(-)
 create mode 100644 src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/ExceptionTestExtensions.WithDiagnostics.cs
 create mode 100644 src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.WithDiagnostics.cs

diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs
index ad8a524b0fc8cc..2f624f6cec974e 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs
@@ -339,17 +339,21 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                                             foundException |= lp.IsException;
                                             foundLogLevel |= lp.IsLogLevel;
 
+                                            bool forceAsTemplateParams = false;
                                             if (lp.IsLogger && lm.TemplateMap.ContainsKey(paramName))
                                             {
                                                 Diag(DiagnosticDescriptors.ShouldntMentionLoggerInMessage, paramSymbol.Locations[0], paramName);
+                                                forceAsTemplateParams = true;
                                             }
                                             else if (lp.IsException && lm.TemplateMap.ContainsKey(paramName))
                                             {
                                                 Diag(DiagnosticDescriptors.ShouldntMentionExceptionInMessage, paramSymbol.Locations[0], paramName);
+                                                forceAsTemplateParams = true;
                                             }
                                             else if (lp.IsLogLevel && lm.TemplateMap.ContainsKey(paramName))
                                             {
                                                 Diag(DiagnosticDescriptors.ShouldntMentionLogLevelInMessage, paramSymbol.Locations[0], paramName);
+                                                forceAsTemplateParams = true;
                                             }
                                             else if (lp.IsLogLevel && level != null && !lm.TemplateMap.ContainsKey(paramName))
                                             {
@@ -368,7 +372,7 @@ public IReadOnlyList<LoggerClass> GetLogClasses(IEnumerable<ClassDeclarationSynt
                                             }
 
                                             lm.AllParameters.Add(lp);
-                                            if (lp.IsTemplateParameter)
+                                            if (lp.IsTemplateParameter || forceAsTemplateParams)
                                             {
                                                 lm.TemplateParameters.Add(lp);
                                             }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs
index d55bf4a8028d52..eced8b527b1200 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs
@@ -341,6 +341,20 @@ public void LevelTests()
             Assert.Equal(LogLevel.Warning, logger.LastLogLevel);
             Assert.Equal(1, logger.CallCount);
             Assert.Equal(11, logger.LastEventId.Id);
+
+            logger.Reset();
+            LevelTestExtensions.M12(logger, LogLevel.Trace);
+            Assert.Null(logger.LastException);
+            Assert.Equal("M12 Trace", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Trace, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            LevelTestExtensions.M13(logger, LogLevel.Trace);
+            Assert.Null(logger.LastException);
+            Assert.Equal("M13 Microsoft.Extensions.Logging.Generators.Tests.MockLogger", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Trace, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
         }
 
         [Fact]
@@ -361,6 +375,13 @@ public void ExceptionTests()
             Assert.Equal("M1 System.ArgumentException: Bar", logger.LastFormattedString);
             Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
             Assert.Equal(1, logger.CallCount);
+
+            logger.Reset();
+            ExceptionTestExtensions.M2(logger, "One", new ArgumentException("Foo"));
+            Assert.Equal("Foo", logger.LastException!.Message);
+            Assert.Equal("M2 One: System.ArgumentException: Foo", logger.LastFormattedString);
+            Assert.Equal(LogLevel.Debug, logger.LastLogLevel);
+            Assert.Equal(1, logger.CallCount);
         }
 
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
index cc0b8ba1adfe36..0cd1371b9b213d 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
@@ -27,7 +27,7 @@ public async Task TestEmitter()
                     new[] { typeof(ILogger).Assembly, typeof(LoggerMessageAttribute).Assembly },
                     new[] { testSourceCode }).ConfigureAwait(false);
 
-                Assert.Empty(d);
+                Assert.True(src.Contains("WithDiagnostics") ? !d.IsEmpty : d.IsEmpty);
                 Assert.Single(r);
             }
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs
index 3c3ce17ef0b181..9edd953f997dfc 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs
@@ -204,11 +204,15 @@ partial class C
                 {
                     [LoggerMessage(EventId = 0, Level = LogLevel.Debug, Message = ""M1 {ex} {ex2}"")]
                     static partial void M1(ILogger logger, System.Exception ex, System.Exception ex2);
+
+                    [LoggerMessage(EventId = 2, Level = LogLevel.Debug, Message = ""M2 {arg1}: {ex}"")]
+                    static partial void M2(ILogger logger, string arg1, System.Exception ex);
                 }
             ");
 
-            Assert.Single(diagnostics);
+            Assert.Equal(2, diagnostics.Count);
             Assert.Equal(DiagnosticDescriptors.ShouldntMentionExceptionInMessage.Id, diagnostics[0].Id);
+            Assert.Equal(DiagnosticDescriptors.ShouldntMentionExceptionInMessage.Id, diagnostics[1].Id);
         }
 
         [Fact]
@@ -234,11 +238,15 @@ partial class C
                 {
                     [LoggerMessage(EventId = 0, Level = LogLevel.Debug, Message = ""M1 {logger}"")]
                     static partial void M1(ILogger logger);
+
+                    [LoggerMessage(EventId = 2, Message = ""M2 {logger}"")]
+                    static partial void M2(ILogger logger, LogLevel level);
                 }
             ");
 
-            Assert.Single(diagnostics);
+            Assert.Equal(2, diagnostics.Count);
             Assert.Equal(DiagnosticDescriptors.ShouldntMentionLoggerInMessage.Id, diagnostics[0].Id);
+            Assert.Equal(DiagnosticDescriptors.ShouldntMentionLoggerInMessage.Id, diagnostics[1].Id);
         }
 
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/ExceptionTestExtensions.WithDiagnostics.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/ExceptionTestExtensions.WithDiagnostics.cs
new file mode 100644
index 00000000000000..8a2299cf864cd4
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/ExceptionTestExtensions.WithDiagnostics.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{
+    internal static partial class ExceptionTestExtensions
+    {
+#pragma warning disable SYSLIB1013
+        [LoggerMessage(EventId = 2, Level = LogLevel.Debug, Message = "M2 {arg1}: {ex}")]
+        public static partial void M2(ILogger logger, string arg1, Exception ex);
+#pragma warning disable SYSLIB1013
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.WithDiagnostics.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.WithDiagnostics.cs
new file mode 100644
index 00000000000000..aabcb67ae4bd07
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/TestClasses/LevelTestExtensions.WithDiagnostics.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Extensions.Logging.Generators.Tests.TestClasses
+{
+    internal static partial class LevelTestExtensions
+    {
+#pragma warning disable SYSLIB1002
+        [LoggerMessage(EventId = 12, Message = "M12 {level}")]
+        public static partial void M12(ILogger logger, LogLevel level);
+#pragma warning restore SYSLIB1002
+
+#pragma warning disable SYSLIB1018
+        [LoggerMessage(EventId = 13, Message = "M13 {logger}")]
+        public static partial void M13(ILogger logger, LogLevel level);
+#pragma warning restore SYSLIB1018
+    }
+}

From 6dfbc6e2277cd8097b33e90002844364a147e74c Mon Sep 17 00:00:00 2001
From: Radek Zikmund <32671551+rzikm@users.noreply.github.com>
Date: Wed, 26 Jan 2022 20:26:49 +0100
Subject: [PATCH 092/161] Fix IsMutuallyAuthenticated on Linux and OSX (#63945)

* WIP - prepared a failing test

* Fix IsMutuallyAuthenticated on Linux

* Fix failing unit tests

* Minor cleanup

* Port changes to OSX

* Fix comment

* Invoke cert selection inline, don't allocate new credentials on Linux/OSX

* Fix tests on OSX

* Code review feedback

* Move tests to separate file

* Fix build

* Fix Failing tests
---
 .../Interop.OpenSsl.cs                        |   9 +-
 .../Security/Pal.OSX/SafeDeleteSslContext.cs  |   1 +
 .../src/System/Net/Security/SecureChannel.cs  | 115 ++++++++++--------
 .../Net/Security/SslStreamPal.Android.cs      |   9 +-
 .../System/Net/Security/SslStreamPal.OSX.cs   |  41 +++----
 .../System/Net/Security/SslStreamPal.Unix.cs  |  61 +++++-----
 .../Net/Security/SslStreamPal.Windows.cs      |  26 +++-
 .../SslStreamMutualAuthenticationTest.cs      |  95 +++++++++++++++
 .../System.Net.Security.Tests.csproj          |   1 +
 9 files changed, 238 insertions(+), 120 deletions(-)
 create mode 100644 src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamMutualAuthenticationTest.cs

diff --git a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.OpenSsl.cs b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.OpenSsl.cs
index d403daac342ad1..12b75443f74723 100644
--- a/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.OpenSsl.cs
+++ b/src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.OpenSsl.cs
@@ -327,12 +327,9 @@ internal static SafeSslHandle AllocateSslHandle(SafeFreeSslCredentials credentia
                         Crypto.ErrClearError();
                     }
 
-                    if (sslAuthenticationOptions.CertSelectionDelegate != null && sslAuthenticationOptions.CertificateContext == null)
-                    {
-                        // We don't have certificate but we have callback. We should wait for remote certificate and
-                        // possible trusted issuer list.
-                        Interop.Ssl.SslSetClientCertCallback(sslHandle, 1);
-                    }
+                    // Set client cert callback, this will interrupt the handshake with SecurityStatusPalErrorCode.CredentialsNeeded
+                    // if server actually requests a certificate.
+                    Ssl.SslSetClientCertCallback(sslHandle, 1);
                 }
 
                 if (sslAuthenticationOptions.IsServer && sslAuthenticationOptions.RemoteCertRequired)
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/Pal.OSX/SafeDeleteSslContext.cs b/src/libraries/System.Net.Security/src/System/Net/Security/Pal.OSX/SafeDeleteSslContext.cs
index 3690837e33f679..9e1a445d9dc750 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/Pal.OSX/SafeDeleteSslContext.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/Pal.OSX/SafeDeleteSslContext.cs
@@ -130,6 +130,7 @@ private static SafeSslHandle CreateSslContext(SafeFreeSslCredentials credential,
                     SetCertificate(sslContext, credential.CertificateContext);
                 }
 
+                Interop.AppleCrypto.SslBreakOnCertRequested(sslContext, true);
                 Interop.AppleCrypto.SslBreakOnServerAuth(sslContext, true);
                 Interop.AppleCrypto.SslBreakOnClientAuth(sslContext, true);
             }
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SecureChannel.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SecureChannel.cs
index 6a2135616f1d55..e3363ddc1c34a2 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/SecureChannel.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/SecureChannel.cs
@@ -295,62 +295,24 @@ private string[] GetRequestCertificateAuthorities()
             return issuers;
         }
 
-        /*++
-            AcquireCredentials - Attempts to find Client Credential
-            Information, that can be sent to the server.  In our case,
-            this is only Client Certificates, that we have Credential Info.
-
-            How it works:
-                case 0: Cert Selection delegate is present
-                        Always use its result as the client cert answer.
-                        Try to use cached credential handle whenever feasible.
-                        Do not use cached anonymous creds if the delegate has returned null
-                        and the collection is not empty (allow responding with the cert later).
-
-                case 1: Certs collection is empty
-                        Always use the same statically acquired anonymous SSL Credential
-
-                case 2: Before our Connection with the Server
-                        If we have a cached credential handle keyed by first X509Certificate
-                        **content** in the passed collection, then we use that cached
-                        credential and hoping to restart a session.
-
-                        Otherwise create a new anonymous (allow responding with the cert later).
-
-                case 3: After our Connection with the Server (i.e. during handshake or re-handshake)
-                        The server has requested that we send it a Certificate then
-                        we Enumerate a list of server sent Issuers trying to match against
-                        our list of Certificates, the first match is sent to the server.
-
-                        Once we got a cert we again try to match cached credential handle if possible.
-                        This will not restart a session but helps minimizing the number of handles we create.
-
-                In the case of an error getting a Certificate or checking its private Key we fall back
-                to the behavior of having no certs, case 1.
-
-            Returns: True if cached creds were used, false otherwise.
-
-        --*/
-
-        private bool AcquireClientCredentials(ref byte[]? thumbPrint)
+        internal X509Certificate2? SelectClientCertificate(out bool sessionRestartAttempt)
         {
-            // Acquire possible Client Certificate information and set it on the handle.
-            X509Certificate? clientCertificate = null;        // This is a candidate that can come from the user callback or be guessed when targeting a session restart.
-            List<X509Certificate>? filteredCerts = null;      // This is an intermediate client certs collection that try to use if no selectedCert is available yet.
-            string[] issuers;                                // This is a list of issuers sent by the server, only valid is we do know what the server cert is.
+            sessionRestartAttempt = false;
 
-            bool sessionRestartAttempt = false; // If true and no cached creds we will use anonymous creds.
+            X509Certificate? clientCertificate = null;        // candidate certificate that can come from the user callback or be guessed when targeting a session restart.
+            X509Certificate2? selectedCert = null;     // final selected cert (ensured that it does have private key with it).
+            List<X509Certificate>? filteredCerts = null;      // This is an intermediate client certs collection that try to use if no selectedCert is available yet.
+            string[] issuers;                                // This is a list of issuers sent by the server, only valid if we do know what the server cert is.
 
             if (_sslAuthenticationOptions.CertSelectionDelegate != null)
             {
-                issuers = GetRequestCertificateAuthorities();
-
                 if (NetEventSource.Log.IsEnabled())
                     NetEventSource.Info(this, "Calling CertificateSelectionCallback");
 
                 X509Certificate2? remoteCert = null;
                 try
                 {
+                    issuers = GetRequestCertificateAuthorities();
                     remoteCert = CertificateValidationPal.GetRemoteCertificate(_securityContext!);
                     if (_sslAuthenticationOptions.ClientCertificates == null)
                     {
@@ -363,7 +325,6 @@ private bool AcquireClientCredentials(ref byte[]? thumbPrint)
                     remoteCert?.Dispose();
                 }
 
-
                 if (clientCertificate != null)
                 {
                     if (_credentialsHandle == null)
@@ -505,9 +466,6 @@ private bool AcquireClientCredentials(ref byte[]? thumbPrint)
                 }
             }
 
-            bool cachedCred = false;                   // This is a return result from this method.
-            X509Certificate2? selectedCert = null;     // This is a final selected cert (ensured that it does have private key with it).
-
             clientCertificate = null;
 
             if (NetEventSource.Log.IsEnabled())
@@ -550,6 +508,56 @@ private bool AcquireClientCredentials(ref byte[]? thumbPrint)
 
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"Selected cert = {selectedCert}");
 
+            _selectedClientCertificate = clientCertificate;
+            return selectedCert;
+        }
+
+        /*++
+            AcquireCredentials - Attempts to find Client Credential
+            Information, that can be sent to the server.  In our case,
+            this is only Client Certificates, that we have Credential Info.
+
+            How it works:
+                case 0: Cert Selection delegate is present
+                        Always use its result as the client cert answer.
+                        Try to use cached credential handle whenever feasible.
+                        Do not use cached anonymous creds if the delegate has returned null
+                        and the collection is not empty (allow responding with the cert later).
+
+                case 1: Certs collection is empty
+                        Always use the same statically acquired anonymous SSL Credential
+
+                case 2: Before our Connection with the Server
+                        If we have a cached credential handle keyed by first X509Certificate
+                        **content** in the passed collection, then we use that cached
+                        credential and hoping to restart a session.
+
+                        Otherwise create a new anonymous (allow responding with the cert later).
+
+                case 3: After our Connection with the Server (i.e. during handshake or re-handshake)
+                        The server has requested that we send it a Certificate then
+                        we Enumerate a list of server sent Issuers trying to match against
+                        our list of Certificates, the first match is sent to the server.
+
+                        Once we got a cert we again try to match cached credential handle if possible.
+                        This will not restart a session but helps minimizing the number of handles we create.
+
+                In the case of an error getting a Certificate or checking its private Key we fall back
+                to the behavior of having no certs, case 1.
+
+            Returns: True if cached creds were used, false otherwise.
+
+        --*/
+
+        private bool AcquireClientCredentials(ref byte[]? thumbPrint)
+        {
+            // Acquire possible Client Certificate information and set it on the handle.
+
+            bool sessionRestartAttempt; // If true and no cached creds we will use anonymous creds.
+            bool cachedCred = false;                   // this is a return result from this method.
+
+            X509Certificate2? selectedCert = SelectClientCertificate(out sessionRestartAttempt);
+
             try
             {
                 // Try to locate cached creds first.
@@ -574,14 +582,14 @@ private bool AcquireClientCredentials(ref byte[]? thumbPrint)
                     // So we don't want to reuse **anonymous** cached credential for a new SSL connection if the client has passed some certificate.
                     // The following block happens if client did specify a certificate but no cached creds were found in the cache.
                     // Since we don't restart a session the server side can still challenge for a client cert.
-                    if ((object?)clientCertificate != (object?)selectedCert)
+                    if ((object?)_selectedClientCertificate != (object?)selectedCert)
                     {
                         selectedCert.Dispose();
                     }
 
                     guessedThumbPrint = null;
                     selectedCert = null;
-                    clientCertificate = null;
+                    _selectedClientCertificate = null;
                 }
 
                 if (cachedCredentialHandle != null)
@@ -589,7 +597,6 @@ private bool AcquireClientCredentials(ref byte[]? thumbPrint)
                     if (NetEventSource.Log.IsEnabled())
                         NetEventSource.Log.UsingCachedCredential(this);
                     _credentialsHandle = cachedCredentialHandle;
-                    _selectedClientCertificate = clientCertificate;
                     cachedCred = true;
                     if (selectedCert != null)
                     {
@@ -607,7 +614,6 @@ private bool AcquireClientCredentials(ref byte[]? thumbPrint)
                             _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.EncryptionPolicy, _sslAuthenticationOptions.IsServer);
 
                     thumbPrint = guessedThumbPrint; // Delay until here in case something above threw.
-                    _selectedClientCertificate = clientCertificate;
                 }
             }
             finally
@@ -792,6 +798,7 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte
                     if (_sslAuthenticationOptions.IsServer)
                     {
                         status = SslStreamPal.AcceptSecurityContext(
+                                      this,
                                       ref _credentialsHandle!,
                                       ref _securityContext,
                                       inputBuffer,
@@ -801,6 +808,7 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte
                     else
                     {
                         status = SslStreamPal.InitializeSecurityContext(
+                                       this,
                                        ref _credentialsHandle!,
                                        ref _securityContext,
                                        _sslAuthenticationOptions.TargetHost,
@@ -841,6 +849,7 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte
         internal SecurityStatusPal Renegotiate(out byte[]? output)
         {
             return SslStreamPal.Renegotiate(
+                                      this,
                                       ref _credentialsHandle!,
                                       ref _securityContext,
                                       _sslAuthenticationOptions,
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Android.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Android.cs
index 27c854c99168e7..54187a60c6c293 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Android.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Android.cs
@@ -25,6 +25,7 @@ public static void VerifyPackageInfo()
         }
 
         public static SecurityStatusPal AcceptSecurityContext(
+            SecureChannel secureChannel,
             ref SafeFreeCredentials credential,
             ref SafeDeleteSslContext? context,
             ReadOnlySpan<byte> inputBuffer,
@@ -35,6 +36,7 @@ public static SecurityStatusPal AcceptSecurityContext(
         }
 
         public static SecurityStatusPal InitializeSecurityContext(
+            SecureChannel secureChannel,
             ref SafeFreeCredentials credential,
             ref SafeDeleteSslContext? context,
             string? targetName,
@@ -45,7 +47,12 @@ public static SecurityStatusPal InitializeSecurityContext(
             return HandshakeInternal(credential, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
         }
 
-        public static SecurityStatusPal Renegotiate(ref SafeFreeCredentials? credentialsHandle, ref SafeDeleteSslContext? context, SslAuthenticationOptions sslAuthenticationOptions, out byte[]? outputBuffer)
+        public static SecurityStatusPal Renegotiate(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credentialsHandle,
+            ref SafeDeleteSslContext? context,
+            SslAuthenticationOptions sslAuthenticationOptions,
+            out byte[]? outputBuffer)
         {
             throw new PlatformNotSupportedException();
         }
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.OSX.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.OSX.cs
index 7043b7afe19f4d..6b1b13ca9f2a70 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.OSX.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.OSX.cs
@@ -20,7 +20,7 @@ public static Exception GetException(SecurityStatusPal status)
             return status.Exception ?? new Win32Exception((int)status.ErrorCode);
         }
 
-        internal const bool StartMutualAuthAsAnonymous = false;
+        internal const bool StartMutualAuthAsAnonymous = true;
 
         // SecureTransport is okay with a 0 byte input, but it produces a 0 byte output.
         // Since ST is not producing the framed empty message just call this false and avoid the
@@ -32,16 +32,18 @@ public static void VerifyPackageInfo()
         }
 
         public static SecurityStatusPal AcceptSecurityContext(
+            SecureChannel secureChannel,
             ref SafeFreeCredentials credential,
             ref SafeDeleteSslContext? context,
             ReadOnlySpan<byte> inputBuffer,
             ref byte[]? outputBuffer,
             SslAuthenticationOptions sslAuthenticationOptions)
         {
-            return HandshakeInternal(credential, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
+            return HandshakeInternal(secureChannel, credential, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
         }
 
         public static SecurityStatusPal InitializeSecurityContext(
+            SecureChannel secureChannel,
             ref SafeFreeCredentials credential,
             ref SafeDeleteSslContext? context,
             string? targetName,
@@ -49,10 +51,15 @@ public static SecurityStatusPal InitializeSecurityContext(
             ref byte[]? outputBuffer,
             SslAuthenticationOptions sslAuthenticationOptions)
         {
-            return HandshakeInternal(credential, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
+            return HandshakeInternal(secureChannel, credential, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
         }
 
-        public static SecurityStatusPal Renegotiate(ref SafeFreeCredentials? credentialsHandle, ref SafeDeleteSslContext? context, SslAuthenticationOptions sslAuthenticationOptions, out byte[]? outputBuffer)
+        public static SecurityStatusPal Renegotiate(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credentialsHandle,
+            ref SafeDeleteSslContext? context,
+            SslAuthenticationOptions sslAuthenticationOptions,
+            out byte[]? outputBuffer)
         {
             throw new PlatformNotSupportedException();
         }
@@ -224,6 +231,7 @@ public static void QueryContextConnectionInfo(
         }
 
         private static SecurityStatusPal HandshakeInternal(
+            SecureChannel secureChannel,
             SafeFreeCredentials credential,
             ref SafeDeleteSslContext? context,
             ReadOnlySpan<byte> inputBuffer,
@@ -268,28 +276,11 @@ private static SecurityStatusPal HandshakeInternal(
                 SecurityStatusPal status = PerformHandshake(sslHandle);
                 if (status.ErrorCode == SecurityStatusPalErrorCode.CredentialsNeeded)
                 {
-                    // we should not be here if CertSelectionDelegate is null but better check before dereferencing..
-                    if (sslAuthenticationOptions.CertSelectionDelegate != null)
+                    X509Certificate2? clientCertificate = secureChannel.SelectClientCertificate(out _);
+                    if (clientCertificate != null)
                     {
-                        X509Certificate2? remoteCert = null;
-                        try
-                        {
-                            string[] issuers = CertificateValidationPal.GetRequestCertificateAuthorities(context);
-                            remoteCert = CertificateValidationPal.GetRemoteCertificate(context);
-                            if (sslAuthenticationOptions.ClientCertificates == null)
-                            {
-                                sslAuthenticationOptions.ClientCertificates = new X509CertificateCollection();
-                            }
-                            X509Certificate2 clientCertificate = (X509Certificate2)sslAuthenticationOptions.CertSelectionDelegate(sslAuthenticationOptions.TargetHost!, sslAuthenticationOptions.ClientCertificates, remoteCert, issuers);
-                            if (clientCertificate != null)
-                            {
-                                SafeDeleteSslContext.SetCertificate(sslContext.SslContext,  SslStreamCertificateContext.Create(clientCertificate));
-                            }
-                        }
-                        finally
-                        {
-                            remoteCert?.Dispose();
-                        }
+                        sslAuthenticationOptions.CertificateContext = SslStreamCertificateContext.Create(clientCertificate);
+                        SafeDeleteSslContext.SetCertificate(sslContext.SslContext, sslAuthenticationOptions.CertificateContext);
                     }
 
                     // We either got certificate or we can proceed without it. It is up to the server to decide if either is OK.
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Unix.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Unix.cs
index 63c4efc1edb655..a9192681444bef 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Unix.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Unix.cs
@@ -17,23 +17,34 @@ public static Exception GetException(SecurityStatusPal status)
             return status.Exception ?? new Interop.OpenSsl.SslException((int)status.ErrorCode);
         }
 
-        internal const bool StartMutualAuthAsAnonymous = false;
+        internal const bool StartMutualAuthAsAnonymous = true;
         internal const bool CanEncryptEmptyMessage = false;
 
         public static void VerifyPackageInfo()
         {
         }
 
-        public static SecurityStatusPal AcceptSecurityContext(ref SafeFreeCredentials? credential, ref SafeDeleteSslContext? context,
-            ReadOnlySpan<byte> inputBuffer, ref byte[]? outputBuffer, SslAuthenticationOptions sslAuthenticationOptions)
+        public static SecurityStatusPal AcceptSecurityContext(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credential,
+            ref SafeDeleteSslContext? context,
+            ReadOnlySpan<byte> inputBuffer,
+            ref byte[]? outputBuffer,
+            SslAuthenticationOptions sslAuthenticationOptions)
         {
-            return HandshakeInternal(credential!, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
+            return HandshakeInternal(secureChannel, credential!, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
         }
 
-        public static SecurityStatusPal InitializeSecurityContext(ref SafeFreeCredentials? credential, ref SafeDeleteSslContext? context, string? targetName,
-            ReadOnlySpan<byte> inputBuffer, ref byte[]? outputBuffer, SslAuthenticationOptions sslAuthenticationOptions)
+        public static SecurityStatusPal InitializeSecurityContext(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credential,
+            ref SafeDeleteSslContext? context,
+            string? targetName,
+            ReadOnlySpan<byte> inputBuffer,
+            ref byte[]? outputBuffer,
+            SslAuthenticationOptions sslAuthenticationOptions)
         {
-            return HandshakeInternal(credential!, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
+            return HandshakeInternal(secureChannel, credential!, ref context, inputBuffer, ref outputBuffer, sslAuthenticationOptions);
         }
 
         public static SafeFreeCredentials AcquireCredentialsHandle(SslStreamCertificateContext? certificateContext,
@@ -116,7 +127,12 @@ Interop.Ssl.SslErrorCode.SSL_ERROR_NONE or
             return bindingHandle;
         }
 
-        public static SecurityStatusPal Renegotiate(ref SafeFreeCredentials? credentialsHandle, ref SafeDeleteSslContext? securityContext, SslAuthenticationOptions sslAuthenticationOptions, out byte[]? outputBuffer)
+        public static SecurityStatusPal Renegotiate(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credentialsHandle,
+            ref SafeDeleteSslContext? securityContext,
+            SslAuthenticationOptions sslAuthenticationOptions,
+            out byte[]? outputBuffer)
         {
             var sslContext = ((SafeDeleteSslContext)securityContext!).SslContext;
             SecurityStatusPal status = Interop.OpenSsl.SslRenegotiate(sslContext, out _);
@@ -126,7 +142,7 @@ public static SecurityStatusPal Renegotiate(ref SafeFreeCredentials? credentials
             {
                 return status;
             }
-            return HandshakeInternal(credentialsHandle!, ref securityContext, null, ref outputBuffer, sslAuthenticationOptions);
+            return HandshakeInternal(secureChannel, credentialsHandle!, ref securityContext, null, ref outputBuffer, sslAuthenticationOptions);
         }
 
         public static void QueryContextStreamSizes(SafeDeleteContext? securityContext, out StreamSizes streamSizes)
@@ -139,7 +155,7 @@ public static void QueryContextConnectionInfo(SafeDeleteSslContext securityConte
             connectionInfo = new SslConnectionInfo(securityContext.SslContext);
         }
 
-        private static SecurityStatusPal HandshakeInternal(SafeFreeCredentials credential, ref SafeDeleteSslContext? context,
+        private static SecurityStatusPal HandshakeInternal(SecureChannel secureChannel, SafeFreeCredentials credential, ref SafeDeleteSslContext? context,
             ReadOnlySpan<byte> inputBuffer, ref byte[]? outputBuffer, SslAuthenticationOptions sslAuthenticationOptions)
         {
             Debug.Assert(!credential.IsInvalid);
@@ -158,34 +174,17 @@ private static SecurityStatusPal HandshakeInternal(SafeFreeCredentials credentia
 
                 if (errorCode == SecurityStatusPalErrorCode.CredentialsNeeded)
                 {
-                    if (sslAuthenticationOptions.CertSelectionDelegate != null)
+                    X509Certificate2? clientCertificate = secureChannel.SelectClientCertificate(out _);
+                    if (clientCertificate != null)
                     {
-                        X509Certificate2? remoteCert = null;
-                        string[] issuers = CertificateValidationPal.GetRequestCertificateAuthorities(context);
-                        try
-                        {
-                            remoteCert = CertificateValidationPal.GetRemoteCertificate(context);
-                            if (sslAuthenticationOptions.ClientCertificates == null)
-                            {
-                                sslAuthenticationOptions.ClientCertificates = new X509CertificateCollection();
-                            }
-                            X509Certificate2 clientCertificate = (X509Certificate2)sslAuthenticationOptions.CertSelectionDelegate(sslAuthenticationOptions.TargetHost!, sslAuthenticationOptions.ClientCertificates, remoteCert, issuers);
-                            if (clientCertificate != null && clientCertificate.HasPrivateKey)
-                            {
-                                sslAuthenticationOptions.CertificateContext = SslStreamCertificateContext.Create(clientCertificate);
-                            }
-                        }
-                        finally
-                        {
-                            remoteCert?.Dispose();
-                        }
+                        sslAuthenticationOptions.CertificateContext = SslStreamCertificateContext.Create(clientCertificate);
                     }
 
                     Interop.OpenSsl.UpdateClientCertiticate(((SafeDeleteSslContext)context).SslContext, sslAuthenticationOptions);
                     errorCode = Interop.OpenSsl.DoSslHandshake(((SafeDeleteSslContext)context).SslContext, null, out output, out outputSize);
                 }
 
-                // sometimes during renegotiation processing messgae does not yield new output.
+                // sometimes during renegotiation processing message does not yield new output.
                 // That seems to be flaw in OpenSSL state machine and we have workaround to peek it and try it again.
                 if (outputSize == 0 && Interop.Ssl.IsSslRenegotiatePending(((SafeDeleteSslContext)context).SslContext))
                 {
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Windows.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Windows.cs
index 2fb36e595b20da..2cb0f2ec14e66c 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Windows.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Windows.cs
@@ -52,7 +52,13 @@ public static byte[] ConvertAlpnProtocolListToByteArray(List<SslApplicationProto
             return Interop.Sec_Application_Protocols.ToByteArray(protocols);
         }
 
-        public static SecurityStatusPal AcceptSecurityContext(ref SafeFreeCredentials? credentialsHandle, ref SafeDeleteSslContext? context, ReadOnlySpan<byte> inputBuffer, ref byte[]? outputBuffer, SslAuthenticationOptions sslAuthenticationOptions)
+        public static SecurityStatusPal AcceptSecurityContext(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credentialsHandle,
+            ref SafeDeleteSslContext? context,
+            ReadOnlySpan<byte> inputBuffer,
+            ref byte[]? outputBuffer,
+            SslAuthenticationOptions sslAuthenticationOptions)
         {
             Interop.SspiCli.ContextFlags unusedAttributes = default;
 
@@ -82,7 +88,14 @@ public static SecurityStatusPal AcceptSecurityContext(ref SafeFreeCredentials? c
             return SecurityStatusAdapterPal.GetSecurityStatusPalFromNativeInt(errorCode);
         }
 
-        public static SecurityStatusPal InitializeSecurityContext(ref SafeFreeCredentials? credentialsHandle, ref SafeDeleteSslContext? context, string? targetName, ReadOnlySpan<byte> inputBuffer, ref byte[]? outputBuffer, SslAuthenticationOptions sslAuthenticationOptions)
+        public static SecurityStatusPal InitializeSecurityContext(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credentialsHandle,
+            ref SafeDeleteSslContext? context,
+            string? targetName,
+            ReadOnlySpan<byte> inputBuffer,
+            ref byte[]? outputBuffer,
+            SslAuthenticationOptions sslAuthenticationOptions)
         {
             Interop.SspiCli.ContextFlags unusedAttributes = default;
 
@@ -112,10 +125,15 @@ public static SecurityStatusPal InitializeSecurityContext(ref SafeFreeCredential
             return SecurityStatusAdapterPal.GetSecurityStatusPalFromNativeInt(errorCode);
         }
 
-        public static SecurityStatusPal Renegotiate(ref SafeFreeCredentials? credentialsHandle, ref SafeDeleteSslContext? context, SslAuthenticationOptions sslAuthenticationOptions, out byte[]? outputBuffer )
+        public static SecurityStatusPal Renegotiate(
+            SecureChannel secureChannel,
+            ref SafeFreeCredentials? credentialsHandle,
+            ref SafeDeleteSslContext? context,
+            SslAuthenticationOptions sslAuthenticationOptions,
+            out byte[]? outputBuffer )
         {
             byte[]? output = Array.Empty<byte>();
-            SecurityStatusPal status =  AcceptSecurityContext(ref credentialsHandle, ref context, Span<byte>.Empty, ref output, sslAuthenticationOptions);
+            SecurityStatusPal status =  AcceptSecurityContext(secureChannel, ref credentialsHandle, ref context, Span<byte>.Empty, ref output, sslAuthenticationOptions);
             outputBuffer = output;
             return status;
         }
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamMutualAuthenticationTest.cs b/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamMutualAuthenticationTest.cs
new file mode 100644
index 00000000000000..adf161fabd49f1
--- /dev/null
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamMutualAuthenticationTest.cs
@@ -0,0 +1,95 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using System.Threading.Tasks;
+using System.Net.Test.Common;
+using System.Security.Cryptography.X509Certificates;
+
+using Xunit;
+
+namespace System.Net.Security.Tests
+{
+    using Configuration = System.Net.Test.Common.Configuration;
+
+    public class SslStreamMutualAuthenticationTest
+    {
+        private readonly X509Certificate2 _clientCertificate;
+        private readonly X509Certificate2 _serverCertificate;
+
+        public SslStreamMutualAuthenticationTest()
+        {
+            _serverCertificate = Configuration.Certificates.GetServerCertificate();
+            _clientCertificate = Configuration.Certificates.GetClientCertificate();
+        }
+
+        [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindows7))]
+        [InlineData(false, false)]
+        [InlineData(false, true)]
+        [InlineData(true, false)]
+        [InlineData(true, true)]
+        public async Task SslStream_RequireClientCert_IsMutuallyAuthenticated_ReturnsTrue(bool clientCertificateRequired, bool useClientSelectionCallback)
+        {
+            (Stream stream1, Stream stream2) = TestHelper.GetConnectedStreams();
+            using (var client = new SslStream(stream1, false, AllowAnyCertificate))
+            using (var server = new SslStream(stream2, false, AllowAnyCertificate))
+            {
+                Task t2 = client.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
+                {
+                    ClientCertificates = useClientSelectionCallback ? null : new X509CertificateCollection() { _clientCertificate },
+                    LocalCertificateSelectionCallback = useClientSelectionCallback ? ClientCertSelectionCallback : null,
+                    TargetHost = _clientCertificate.GetNameInfo(X509NameType.SimpleName, false)
+                });
+                Task t1 = server.AuthenticateAsServerAsync(new SslServerAuthenticationOptions
+                {
+                    ServerCertificate = _serverCertificate,
+                    ClientCertificateRequired = clientCertificateRequired
+                });
+
+                await TestConfiguration.WhenAllOrAnyFailedWithTimeout(t1, t2);
+
+                if (Capability.IsTrustedRootCertificateInstalled())
+                {
+                    // https://technet.microsoft.com/en-us/library/hh831771.aspx#BKMK_Changes2012R2
+                    // Starting with Windows 8, the "Management of trusted issuers for client authentication" has changed:
+                    // The behavior to send the Trusted Issuers List by default is off.
+                    //
+                    // In Windows 7 the Trusted Issuers List is sent within the Server Hello TLS record. This list is built
+                    // by the server using certificates from the Trusted Root Authorities certificate store.
+                    // The client side will use the Trusted Issuers List, if not empty, to filter proposed certificates.
+
+                    if (clientCertificateRequired)
+                    {
+                        Assert.True(client.IsMutuallyAuthenticated, "client.IsMutuallyAuthenticated");
+                        Assert.True(server.IsMutuallyAuthenticated, "server.IsMutuallyAuthenticated");
+                    }
+                    else
+                    {
+                        // Even though the certificate was provided, it was not requested by the server and thus the client
+                        // was not authenticated.
+                        Assert.False(client.IsMutuallyAuthenticated, "client.IsMutuallyAuthenticated");
+                        Assert.False(server.IsMutuallyAuthenticated, "server.IsMutuallyAuthenticated");
+                    }
+                }
+            }
+        }
+
+        private static bool AllowAnyCertificate(
+            object sender,
+            X509Certificate certificate,
+            X509Chain chain,
+            SslPolicyErrors sslPolicyErrors)
+        {
+            return true;
+        }
+        private X509Certificate ClientCertSelectionCallback(
+            object sender,
+            string targetHost,
+            X509CertificateCollection localCertificates,
+            X509Certificate remoteCertificate,
+            string[] acceptableIssuers)
+        {
+            return _clientCertificate;
+        }
+    }
+}
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj b/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj
index a6a21cc91e155b..ea97df3db286a6 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj
@@ -28,6 +28,7 @@
     <Compile Include="SslStreamConformanceTests.cs" />
     <Compile Include="SslStreamStreamToStreamTest.cs" />
     <Compile Include="SslStreamNetworkStreamTest.cs" />
+    <Compile Include="SslStreamMutualAuthenticationTest.cs" />
     <Compile Include="TransportContextTest.cs" />
     <!-- NegotiateStream Tests -->
     <Compile Include="NegotiateStreamConformanceTests.cs" />

From ea69502cb15b6fdd877bffb0c2f9e4242b66434a Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Wed, 26 Jan 2022 14:56:15 -0500
Subject: [PATCH 093/161] Support {Last}IndexOfAny with sets after {lazy} loops
 (#64254)

When emitting backtracking loops, the loop consumes as much and then backtracks through the consumed input.  Rather than doing this one character by one character, we previously added use of LastIndexOf to search for the next place the literal after the loop matches.  We can also augment that to use IndexOfAny to search for a small set that comes after a loop instead of a literal.

Similarly when emitting backtracking lazy loops, rather than consuming one character and trying the rest of the expression and then consuming another character and trying the rest of the expression, we previously added an optimization to use IndexOf{Any} to find the next possible location of a match based on the literal that comes after the lazy loop.  And we can similarly augment that to support a small set after the lazy loop.

This is particularly helpful for IgnoreCase, as we're on a path to replacing literals with sets that contain all equivalent casings of that character.
---
 .../gen/RegexGenerator.Emitter.cs             | 39 ++++++--
 .../Text/RegularExpressions/RegexCompiler.cs  | 93 +++++++++++++++++--
 .../Text/RegularExpressions/RegexNode.cs      | 25 ++++-
 .../tests/Regex.Match.Tests.cs                | 46 ++++++++-
 4 files changed, 180 insertions(+), 23 deletions(-)

diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
index 820490c500298e..af4f27b59151fb 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
+++ b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
@@ -2391,12 +2391,18 @@ void EmitSingleCharLoop(RegexNode node, RegexNode? subsequent = null, bool emitL
                 EmitStackPop(endingPos, startingPos);
                 writer.WriteLine();
 
-                if (subsequent?.FindStartingCharacterOrString() is ValueTuple<char, string?> literal)
+                if (subsequent?.FindStartingLiteral() is ValueTuple<char, string?, string?> literal)
                 {
                     writer.WriteLine($"if ({startingPos} >= {endingPos} ||");
-                    using (EmitBlock(writer, literal.Item2 is not null ?
-                        $"    ({endingPos} = global::System.MemoryExtensions.LastIndexOf(inputSpan.Slice({startingPos}, global::System.Math.Min(inputSpan.Length, {endingPos} + {literal.Item2.Length - 1}) - {startingPos}), {Literal(literal.Item2)})) < 0)" :
-                        $"    ({endingPos} = global::System.MemoryExtensions.LastIndexOf(inputSpan.Slice({startingPos}, {endingPos} - {startingPos}), {Literal(literal.Item1)})) < 0)"))
+                    using (EmitBlock(writer,
+                        literal.Item2 is not null ? $"    ({endingPos} = global::System.MemoryExtensions.LastIndexOf(inputSpan.Slice({startingPos}, global::System.Math.Min(inputSpan.Length, {endingPos} + {literal.Item2.Length - 1}) - {startingPos}), {Literal(literal.Item2)})) < 0)" :
+                        literal.Item3 is null ? $"    ({endingPos} = global::System.MemoryExtensions.LastIndexOf(inputSpan.Slice({startingPos}, {endingPos} - {startingPos}), {Literal(literal.Item1)})) < 0)" :
+                        literal.Item3.Length switch
+                        {
+                            2 => $"    ({endingPos} = global::System.MemoryExtensions.LastIndexOfAny(inputSpan.Slice({startingPos}, {endingPos} - {startingPos}), {Literal(literal.Item3[0])}, {Literal(literal.Item3[1])})) < 0)",
+                            3 => $"    ({endingPos} = global::System.MemoryExtensions.LastIndexOfAny(inputSpan.Slice({startingPos}, {endingPos} - {startingPos}), {Literal(literal.Item3[0])}, {Literal(literal.Item3[1])}, {Literal(literal.Item3[2])})) < 0)",
+                            _ => $"    ({endingPos} = global::System.MemoryExtensions.LastIndexOfAny(inputSpan.Slice({startingPos}, {endingPos} - {startingPos}), {Literal(literal.Item3)})) < 0)",
+                        }))
                     {
                         writer.WriteLine($"goto {doneLabel};");
                     }
@@ -2516,14 +2522,21 @@ void EmitSingleCharLazy(RegexNode node, RegexNode? subsequent = null, bool emitL
                 if (iterationCount is null &&
                     node.Kind is RegexNodeKind.Notonelazy &&
                     !IsCaseInsensitive(node) &&
-                    subsequent?.FindStartingCharacterOrString() is ValueTuple<char, string?> literal &&
-                    (literal.Item2?[0] ?? literal.Item1) != node.Ch)
+                    subsequent?.FindStartingLiteral(4) is ValueTuple<char, string?, string?> literal && // 5 == max optimized by IndexOfAny, and we need to reserve 1 for node.Ch
+                    (literal.Item3 is not null ? !literal.Item3.Contains(node.Ch) : (literal.Item2?[0] ?? literal.Item1) != node.Ch)) // no overlap between node.Ch and the start of the literal
                 {
                     // e.g. "<[^>]*?>"
                     // This lazy loop will consume all characters other than node.Ch until the subsequent literal.
                     // We can implement it to search for either that char or the literal, whichever comes first.
                     // If it ends up being that node.Ch, the loop fails (we're only here if we're backtracking).
-                    writer.WriteLine($"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(node.Ch)}, {Literal(literal.Item2?[0] ?? literal.Item1)});");
+                    writer.WriteLine(
+                        literal.Item2 is not null ? $"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(node.Ch)}, {Literal(literal.Item2[0])});" :
+                        literal.Item3 is null ? $"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(node.Ch)}, {Literal(literal.Item1)});" :
+                        literal.Item3.Length switch
+                        {
+                            2 => $"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(node.Ch)}, {Literal(literal.Item3[0])}, {Literal(literal.Item3[1])});",
+                            _ => $"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(node.Ch + literal.Item3)});",
+                        });
                     using (EmitBlock(writer, $"if ((uint){startingPos} >= (uint){sliceSpan}.Length || {sliceSpan}[{startingPos}] == {Literal(node.Ch)})"))
                     {
                         writer.WriteLine($"goto {doneLabel};");
@@ -2534,12 +2547,20 @@ node.Kind is RegexNodeKind.Notonelazy &&
                 else if (iterationCount is null &&
                     node.Kind is RegexNodeKind.Setlazy &&
                     node.Str == RegexCharClass.AnyClass &&
-                    subsequent?.FindStartingCharacterOrString() is ValueTuple<char, string?> literal2)
+                    subsequent?.FindStartingLiteral() is ValueTuple<char, string?, string?> literal2)
                 {
                     // e.g. ".*?string" with RegexOptions.Singleline
                     // This lazy loop will consume all characters until the subsequent literal. If the subsequent literal
                     // isn't found, the loop fails. We can implement it to just search for that literal.
-                    writer.WriteLine($"{startingPos} = global::System.MemoryExtensions.IndexOf({sliceSpan}, {(literal2.Item2 is not null ? Literal(literal2.Item2) : Literal(literal2.Item1))});");
+                    writer.WriteLine(
+                        literal2.Item2 is not null ? $"{startingPos} = global::System.MemoryExtensions.IndexOf({sliceSpan}, {Literal(literal2.Item2)});" :
+                        literal2.Item3 is null ? $"{startingPos} = global::System.MemoryExtensions.IndexOf({sliceSpan}, {Literal(literal2.Item1)});" :
+                        literal2.Item3.Length switch
+                        {
+                            2 => $"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(literal2.Item3[0])}, {Literal(literal2.Item3[1])});",
+                            3 => $"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(literal2.Item3[0])}, {Literal(literal2.Item3[1])}, {Literal(literal2.Item3[2])});",
+                            _ => $"{startingPos} = global::System.MemoryExtensions.IndexOfAny({sliceSpan}, {Literal(literal2.Item3)});",
+                        });
                     using (EmitBlock(writer, $"if ({startingPos} < 0)"))
                     {
                         writer.WriteLine($"goto {doneLabel};");
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
index 1c03616ef37931..4bba264296327e 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
@@ -51,6 +51,9 @@ internal abstract class RegexCompiler
         private static readonly MethodInfo s_spanIndexOfAnyCharCharChar = typeof(MemoryExtensions).GetMethod("IndexOfAny", new Type[] { typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), Type.MakeGenericMethodParameter(0), Type.MakeGenericMethodParameter(0), Type.MakeGenericMethodParameter(0) })!.MakeGenericMethod(typeof(char));
         private static readonly MethodInfo s_spanIndexOfAnySpan = typeof(MemoryExtensions).GetMethod("IndexOfAny", new Type[] { typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) })!.MakeGenericMethod(typeof(char));
         private static readonly MethodInfo s_spanLastIndexOfChar = typeof(MemoryExtensions).GetMethod("LastIndexOf", new Type[] { typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), Type.MakeGenericMethodParameter(0) })!.MakeGenericMethod(typeof(char));
+        private static readonly MethodInfo s_spanLastIndexOfAnyCharChar = typeof(MemoryExtensions).GetMethod("LastIndexOfAny", new Type[] { typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), Type.MakeGenericMethodParameter(0), Type.MakeGenericMethodParameter(0) })!.MakeGenericMethod(typeof(char));
+        private static readonly MethodInfo s_spanLastIndexOfAnyCharCharChar = typeof(MemoryExtensions).GetMethod("LastIndexOfAny", new Type[] { typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), Type.MakeGenericMethodParameter(0), Type.MakeGenericMethodParameter(0), Type.MakeGenericMethodParameter(0) })!.MakeGenericMethod(typeof(char));
+        private static readonly MethodInfo s_spanLastIndexOfAnySpan = typeof(MemoryExtensions).GetMethod("LastIndexOfAny", new Type[] { typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) })!.MakeGenericMethod(typeof(char));
         private static readonly MethodInfo s_spanLastIndexOfSpan = typeof(MemoryExtensions).GetMethod("LastIndexOf", new Type[] { typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), typeof(ReadOnlySpan<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) })!.MakeGenericMethod(typeof(char));
         private static readonly MethodInfo s_spanSliceIntMethod = typeof(ReadOnlySpan<char>).GetMethod("Slice", new Type[] { typeof(int) })!;
         private static readonly MethodInfo s_spanSliceIntIntMethod = typeof(ReadOnlySpan<char>).GetMethod("Slice", new Type[] { typeof(int), typeof(int) })!;
@@ -2611,7 +2614,7 @@ void EmitSingleCharLoop(RegexNode node, RegexNode? subsequent = null, bool emitL
                 Ldloc(endingPos);
                 BgeFar(doneLabel);
 
-                if (subsequent?.FindStartingCharacterOrString() is ValueTuple<char, string?> literal)
+                if (subsequent?.FindStartingLiteral() is ValueTuple<char, string?, string?> literal)
                 {
                     // endingPos = inputSpan.Slice(startingPos, Math.Min(inputSpan.Length, endingPos + literal.Length - 1) - startingPos).LastIndexOf(literal);
                     // if (endingPos < 0)
@@ -2641,8 +2644,35 @@ void EmitSingleCharLoop(RegexNode node, RegexNode? subsequent = null, bool emitL
                         Ldloc(startingPos);
                         Sub();
                         Call(s_spanSliceIntIntMethod);
-                        Ldc(literal.Item1);
-                        Call(s_spanLastIndexOfChar);
+                        if (literal.Item3 is not null)
+                        {
+                            switch (literal.Item3.Length)
+                            {
+                                case 2:
+                                    Ldc(literal.Item3[0]);
+                                    Ldc(literal.Item3[1]);
+                                    Call(s_spanLastIndexOfAnyCharChar);
+                                    break;
+
+                                case 3:
+                                    Ldc(literal.Item3[0]);
+                                    Ldc(literal.Item3[1]);
+                                    Ldc(literal.Item3[2]);
+                                    Call(s_spanLastIndexOfAnyCharCharChar);
+                                    break;
+
+                                default:
+                                    Ldstr(literal.Item3);
+                                    Call(s_stringAsSpanMethod);
+                                    Call(s_spanLastIndexOfAnySpan);
+                                    break;
+                            }
+                        }
+                        else
+                        {
+                            Ldc(literal.Item1);
+                            Call(s_spanLastIndexOfChar);
+                        }
                     }
                     Stloc(endingPos);
                     Ldloc(endingPos);
@@ -2783,8 +2813,8 @@ void EmitSingleCharLazy(RegexNode node, RegexNode? subsequent = null, bool emitL
                 if (iterationCount is null &&
                     node.Kind is RegexNodeKind.Notonelazy &&
                     !IsCaseInsensitive(node) &&
-                    subsequent?.FindStartingCharacterOrString() is ValueTuple<char, string?> literal &&
-                    (literal.Item2?[0] ?? literal.Item1) != node.Ch)
+                    subsequent?.FindStartingLiteral(4) is ValueTuple<char, string?, string?> literal && // 5 == max optimized by IndexOfAny, and we need to reserve 1 for node.Ch
+                    (literal.Item3 is not null ? !literal.Item3.Contains(node.Ch) : (literal.Item2?[0] ?? literal.Item1) != node.Ch)) // no overlap between node.Ch and the start of the literal
                 {
                     // e.g. "<[^>]*?>"
                     // This lazy loop will consume all characters other than node.Ch until the subsequent literal.
@@ -2793,9 +2823,30 @@ node.Kind is RegexNodeKind.Notonelazy &&
 
                     // startingPos = slice.IndexOfAny(node.Ch, literal);
                     Ldloc(slice);
-                    Ldc(node.Ch);
-                    Ldc(literal.Item2?[0] ?? literal.Item1);
-                    Call(s_spanIndexOfAnyCharChar);
+                    if (literal.Item3 is not null)
+                    {
+                        switch (literal.Item3.Length)
+                        {
+                            case 2:
+                                Ldc(node.Ch);
+                                Ldc(literal.Item3[0]);
+                                Ldc(literal.Item3[1]);
+                                Call(s_spanIndexOfAnyCharCharChar);
+                                break;
+
+                            default:
+                                Ldstr(node.Ch + literal.Item3);
+                                Call(s_stringAsSpanMethod);
+                                Call(s_spanIndexOfAnySpan);
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        Ldc(node.Ch);
+                        Ldc(literal.Item2?[0] ?? literal.Item1);
+                        Call(s_spanIndexOfAnyCharChar);
+                    }
                     Stloc(startingPos);
 
                     // if ((uint)startingPos >= (uint)slice.Length) goto doneLabel;
@@ -2823,7 +2874,7 @@ node.Kind is RegexNodeKind.Notonelazy &&
                 else if (iterationCount is null &&
                     node.Kind is RegexNodeKind.Setlazy &&
                     node.Str == RegexCharClass.AnyClass &&
-                    subsequent?.FindStartingCharacterOrString() is ValueTuple<char, string?> literal2)
+                    subsequent?.FindStartingLiteral() is ValueTuple<char, string?, string?> literal2)
                 {
                     // e.g. ".*?string" with RegexOptions.Singleline
                     // This lazy loop will consume all characters until the subsequent literal. If the subsequent literal
@@ -2837,6 +2888,30 @@ node.Kind is RegexNodeKind.Setlazy &&
                         Call(s_stringAsSpanMethod);
                         Call(s_spanIndexOfSpan);
                     }
+                    else if (literal2.Item3 is not null)
+                    {
+                        switch (literal2.Item3.Length)
+                        {
+                            case 2:
+                                Ldc(literal2.Item3[0]);
+                                Ldc(literal2.Item3[1]);
+                                Call(s_spanIndexOfAnyCharChar);
+                                break;
+
+                            case 3:
+                                Ldc(literal2.Item3[0]);
+                                Ldc(literal2.Item3[1]);
+                                Ldc(literal2.Item3[2]);
+                                Call(s_spanIndexOfAnyCharCharChar);
+                                break;
+
+                            default:
+                                Ldstr(literal2.Item3);
+                                Call(s_stringAsSpanMethod);
+                                Call(s_spanIndexOfAnySpan);
+                                break;
+                        }
+                    }
                     else
                     {
                         Ldc(literal2.Item1);
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
index 945f9ac2b4f2de..efd5ef3d45a251 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
@@ -1378,9 +1378,11 @@ public char FirstCharOfOneOrMulti()
             return Kind == RegexNodeKind.One ? Ch : Str![0];
         }
 
-        /// <summary>Finds the guaranteed beginning character of the node, or null if none exists.</summary>
-        public (char Char, string? String)? FindStartingCharacterOrString()
+        /// <summary>Finds the guaranteed beginning literal(s) of the node, or null if none exists.</summary>
+        public (char Char, string? String, string? SetChars)? FindStartingLiteral(int maxSetCharacters = 5) // 5 is max optimized by IndexOfAny today
         {
+            Debug.Assert(maxSetCharacters >= 0 && maxSetCharacters <= 128, $"{nameof(maxSetCharacters)} == {maxSetCharacters} should be small enough to be stack allocated.");
+
             RegexNode? node = this;
             while (true)
             {
@@ -1392,14 +1394,29 @@ public char FirstCharOfOneOrMulti()
                         case RegexNodeKind.Oneloop or RegexNodeKind.Oneloopatomic or RegexNodeKind.Onelazy when node.M > 0:
                             if ((node.Options & RegexOptions.IgnoreCase) == 0 || !RegexCharClass.ParticipatesInCaseConversion(node.Ch))
                             {
-                                return (node.Ch, null);
+                                return (node.Ch, null, null);
                             }
                             break;
 
                         case RegexNodeKind.Multi:
                             if ((node.Options & RegexOptions.IgnoreCase) == 0 || !RegexCharClass.ParticipatesInCaseConversion(node.Str.AsSpan()))
                             {
-                                return ('\0', node.Str);
+                                return ('\0', node.Str, null);
+                            }
+                            break;
+
+                        case RegexNodeKind.Set:
+                        case RegexNodeKind.Setloop or RegexNodeKind.Setloopatomic or RegexNodeKind.Setlazy when node.M > 0:
+                            Span<char> setChars = stackalloc char[maxSetCharacters];
+                            int numChars;
+                            if (!RegexCharClass.IsNegated(node.Str!) &&
+                                (numChars = RegexCharClass.GetSetChars(node.Str!, setChars)) != 0)
+                            {
+                                setChars = setChars.Slice(0, numChars);
+                                if ((node.Options & RegexOptions.IgnoreCase) == 0 || !RegexCharClass.ParticipatesInCaseConversion(setChars))
+                                {
+                                    return ('\0', null, setChars.ToString());
+                                }
                             }
                             break;
 
diff --git a/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs b/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
index e3e466dd64ece3..6cd5dcc3cd3163 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/Regex.Match.Tests.cs
@@ -242,17 +242,61 @@ public static IEnumerable<object[]> Match_MemberData()
                 yield return (@"(\d{2,3}?)+?", "1234", RegexOptions.None, 0, 4, true, "12");
                 yield return (@"(\d{2,3}?)*?", "123456", RegexOptions.None, 0, 4, true, "");
 
-                foreach (RegexOptions lineOption in new[] { RegexOptions.None, RegexOptions.Singleline, RegexOptions.Multiline })
+                foreach (RegexOptions lineOption in new[] { RegexOptions.None, RegexOptions.Singleline })
                 {
                     yield return (@".*", "abc", lineOption, 1, 2, true, "bc");
                     yield return (@".*c", "abc", lineOption, 1, 2, true, "bc");
                     yield return (@"b.*", "abc", lineOption, 1, 2, true, "bc");
                     yield return (@".*", "abc", lineOption, 2, 1, true, "c");
 
+                    yield return (@"a.*[bc]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*[bc]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*[bc]", "xyza12345d6789", lineOption, 0, 14, false, "");
+
+                    yield return (@"a.*[bcd]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*[bcd]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*[bcd]", "xyza12345d6789", lineOption, 0, 14, true, "a12345d");
+                    yield return (@"a.*[bcd]", "xyza12345e6789", lineOption, 0, 14, false, "");
+
+                    yield return (@"a.*[bcde]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*[bcde]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*[bcde]", "xyza12345d6789", lineOption, 0, 14, true, "a12345d");
+                    yield return (@"a.*[bcde]", "xyza12345e6789", lineOption, 0, 14, true, "a12345e");
+                    yield return (@"a.*[bcde]", "xyza12345f6789", lineOption, 0, 14, false, "");
+
+                    yield return (@"a.*[bcdef]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*[bcdef]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*[bcdef]", "xyza12345d6789", lineOption, 0, 14, true, "a12345d");
+                    yield return (@"a.*[bcdef]", "xyza12345e6789", lineOption, 0, 14, true, "a12345e");
+                    yield return (@"a.*[bcdef]", "xyza12345f6789", lineOption, 0, 14, true, "a12345f");
+                    yield return (@"a.*[bcdef]", "xyza12345g6789", lineOption, 0, 14, false, "");
+
                     yield return (@".*?", "abc", lineOption, 1, 2, true, "");
                     yield return (@".*?c", "abc", lineOption, 1, 2, true, "bc");
                     yield return (@"b.*?", "abc", lineOption, 1, 2, true, "b");
                     yield return (@".*?", "abc", lineOption, 2, 1, true, "");
+
+                    yield return (@"a.*?[bc]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*?[bc]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*?[bc]", "xyza12345d6789", lineOption, 0, 14, false, "");
+
+                    yield return (@"a.*?[bcd]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*?[bcd]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*?[bcd]", "xyza12345d6789", lineOption, 0, 14, true, "a12345d");
+                    yield return (@"a.*?[bcd]", "xyza12345e6789", lineOption, 0, 14, false, "");
+
+                    yield return (@"a.*?[bcde]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*?[bcde]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*?[bcde]", "xyza12345d6789", lineOption, 0, 14, true, "a12345d");
+                    yield return (@"a.*?[bcde]", "xyza12345e6789", lineOption, 0, 14, true, "a12345e");
+                    yield return (@"a.*?[bcde]", "xyza12345f6789", lineOption, 0, 14, false, "");
+
+                    yield return (@"a.*?[bcdef]", "xyza12345b6789", lineOption, 0, 14, true, "a12345b");
+                    yield return (@"a.*?[bcdef]", "xyza12345c6789", lineOption, 0, 14, true, "a12345c");
+                    yield return (@"a.*?[bcdef]", "xyza12345d6789", lineOption, 0, 14, true, "a12345d");
+                    yield return (@"a.*?[bcdef]", "xyza12345e6789", lineOption, 0, 14, true, "a12345e");
+                    yield return (@"a.*?[bcdef]", "xyza12345f6789", lineOption, 0, 14, true, "a12345f");
+                    yield return (@"a.*?[bcdef]", "xyza12345g6789", lineOption, 0, 14, false, "");
                 }
 
                 // Nested loops

From f85ea976f81945ea18cd5dc71959cccecdc93cd2 Mon Sep 17 00:00:00 2001
From: Filip Navara <filip.navara@gmail.com>
Date: Wed, 26 Jan 2022 21:19:47 +0100
Subject: [PATCH 094/161] Fix race conditions in SystemEvents shutdown logic
 (#62773)

* Fix race conditions in SystemEvents shutdown logic

When the application is terminated through Restart Manager the event broadcasting window will get the `WM_CLOSE` message. The message gets handled by passing it to `DefWndProc` which calls `DestroyWindow` on the window itself thus making the window handle invalid. The `Shutdown` method expects the window handle to be valid to post `WM_QUIT` message to terminate the thread running the message loop but that's no longer possible under these conditions.

Additionally there's second race condition with the `s_eventThreadTerminated` event that is created during shutdown and set conditionally. A race condition between the threads could cause it to be created when the window message thread is already shutting down and thus it would never be set. Waiting for it in the `Shutdown` method would be cause a deadlock. This thread is also completely unnecessary since a `Join` is performed on the thread itself.

The fix has several changes that act together:
- `s_eventThreadTerminated` event is removed completely in favor of only relying on `Thread.Join`
- `WM_DESTROY` message is detected (which happens as a result of WM_CLOSE calling `DefWndProc` which in turn calls `DestroyWindow`) and handled by shutting down the message loop thread
- The message loop itself is rewritten to use standard `GetMessageW` loop. The reasoning on why it was not used seems not to be valid anymore since AppDomain shutdowns are performed differently

* Add unit test.

* Add braces
---
 .../Windows/User32/Interop.Constants.cs       |  1 +
 ...p.PeekMessage.cs => Interop.GetMessage.cs} |  2 +-
 .../Windows/User32/Interop.PostQuitMessage.cs | 14 +++++
 .../src/Microsoft.Win32.SystemEvents.csproj   |  6 +-
 .../src/Microsoft/Win32/SystemEvents.cs       | 56 +++++++------------
 .../Microsoft.Win32.SystemEvents.Tests.csproj |  1 +
 .../tests/ShutdownTest.cs                     | 33 +++++++++++
 7 files changed, 73 insertions(+), 40 deletions(-)
 rename src/libraries/Common/src/Interop/Windows/User32/{Interop.PeekMessage.cs => Interop.GetMessage.cs} (77%)
 create mode 100644 src/libraries/Common/src/Interop/Windows/User32/Interop.PostQuitMessage.cs
 create mode 100644 src/libraries/Microsoft.Win32.SystemEvents/tests/ShutdownTest.cs

diff --git a/src/libraries/Common/src/Interop/Windows/User32/Interop.Constants.cs b/src/libraries/Common/src/Interop/Windows/User32/Interop.Constants.cs
index 7a1574155a7d9a..e1a9bc4cce2ac3 100644
--- a/src/libraries/Common/src/Interop/Windows/User32/Interop.Constants.cs
+++ b/src/libraries/Common/src/Interop/Windows/User32/Interop.Constants.cs
@@ -198,6 +198,7 @@ internal static partial class User32
 
         public const int WAIT_TIMEOUT = 0x00000102;
 
+        public const int WM_DESTROY = 0x0002;
         public const int WM_CLOSE = 0x0010;
         public const int WM_QUERYENDSESSION = 0x0011;
         public const int WM_QUIT = 0x0012;
diff --git a/src/libraries/Common/src/Interop/Windows/User32/Interop.PeekMessage.cs b/src/libraries/Common/src/Interop/Windows/User32/Interop.GetMessage.cs
similarity index 77%
rename from src/libraries/Common/src/Interop/Windows/User32/Interop.PeekMessage.cs
rename to src/libraries/Common/src/Interop/Windows/User32/Interop.GetMessage.cs
index 6bcfa1488d6848..5f9af4ffc2aa79 100644
--- a/src/libraries/Common/src/Interop/Windows/User32/Interop.PeekMessage.cs
+++ b/src/libraries/Common/src/Interop/Windows/User32/Interop.GetMessage.cs
@@ -9,6 +9,6 @@ internal static partial class Interop
     internal static partial class User32
     {
         [GeneratedDllImport(Libraries.User32, CharSet = CharSet.Unicode, ExactSpelling = true)]
-        public static partial bool PeekMessageW(ref MSG msg, IntPtr hwnd, int msgMin, int msgMax, int remove);
+        public static partial int GetMessageW(ref MSG msg, IntPtr hwnd, int msgMin, int msgMax);
     }
 }
diff --git a/src/libraries/Common/src/Interop/Windows/User32/Interop.PostQuitMessage.cs b/src/libraries/Common/src/Interop/Windows/User32/Interop.PostQuitMessage.cs
new file mode 100644
index 00000000000000..511e68c0f883ba
--- /dev/null
+++ b/src/libraries/Common/src/Interop/Windows/User32/Interop.PostQuitMessage.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [GeneratedDllImport(Libraries.User32, CharSet = CharSet.Unicode, ExactSpelling = true)]
+        public static partial void PostQuitMessage(int exitCode);
+    }
+}
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft.Win32.SystemEvents.csproj b/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft.Win32.SystemEvents.csproj
index 007fd6f60fa58b..0ccd62c3f8c3a0 100644
--- a/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft.Win32.SystemEvents.csproj
+++ b/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft.Win32.SystemEvents.csproj
@@ -35,6 +35,8 @@ Microsoft.Win32.SystemEvents</PackageDescription>
              Link="Common\Interop\Windows\User32\Interop.DispatchMessage.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.GetClassInfo.cs"
              Link="Common\Interop\Windows\User32\Interop.GetClassInfo.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.GetMessage.cs"
+             Link="Common\Interop\Windows\User32\Interop.GetMessage.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.GetProcessWindowStation.cs"
              Link="Common\Interop\Windows\User32\Interop.GetProcessWindowStation.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.GetUserObjectInformation.cs"
@@ -49,10 +51,10 @@ Microsoft.Win32.SystemEvents</PackageDescription>
              Link="Common\Interop\Windows\User32\Interop.MSG.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.MsgWaitForMultipleObjectsEx.cs"
              Link="Common\Interop\Windows\User32\Interop.MsgWaitForMultipleObjectsEx.cs" />
-    <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.PeekMessage.cs"
-             Link="Common\Interop\Windows\User32\Interop.PeekMessage.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.PostMessage.cs"
              Link="Common\Interop\Windows\User32\Interop.PostMessage.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.PostQuitMessage.cs"
+             Link="Common\Interop\Windows\User32\Interop.PostQuitMessage.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.RegisterClass.cs"
              Link="Common\Interop\Windows\User32\Interop.RegisterClass.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.RegisterWindowMessage.cs"
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft/Win32/SystemEvents.cs b/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft/Win32/SystemEvents.cs
index 0f659249417e57..2cee04edc073d0 100644
--- a/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft/Win32/SystemEvents.cs
+++ b/src/libraries/Microsoft.Win32.SystemEvents/src/Microsoft/Win32/SystemEvents.cs
@@ -35,7 +35,6 @@ public sealed class SystemEvents
         // cross-thread marshaling
         private static volatile Queue<Delegate>? s_threadCallbackList; // list of Delegates
         private static volatile int s_threadCallbackMessage;
-        private static volatile ManualResetEvent? s_eventThreadTerminated;
 
         // Per-instance data that is isolated to the window thread.
         private volatile IntPtr _windowHandle;
@@ -1071,7 +1070,7 @@ private static void RemoveEventHandler(object key, Delegate? value)
 
         private static void Shutdown()
         {
-            if (s_systemEvents != null && s_systemEvents._windowHandle != IntPtr.Zero)
+            if (s_systemEvents != null)
             {
                 lock (s_procLockObject)
                 {
@@ -1080,17 +1079,22 @@ private static void Shutdown()
                         // If we are using system events from another thread, request that it terminate
                         if (s_windowThread != null)
                         {
-                            s_eventThreadTerminated = new ManualResetEvent(false);
-
 #if DEBUG
                             int pid;
                             int thread = Interop.User32.GetWindowThreadProcessId(new HandleRef(s_systemEvents, s_systemEvents._windowHandle), out pid);
                             Debug.Assert(thread != Interop.Kernel32.GetCurrentThreadId(), "Don't call Shutdown on the system events thread");
 #endif
-                            Interop.User32.PostMessageW(new HandleRef(s_systemEvents, s_systemEvents._windowHandle), Interop.User32.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
 
-                            s_eventThreadTerminated.WaitOne();
-                            s_windowThread.Join(); // avoids an AppDomainUnloaded exception on our background thread.
+                            // The handle could be valid, Zero or invalid depending on the state of the thread
+                            // that is processing the messages. We optimistically expect it to be valid to
+                            // notify the thread to shutdown. The Zero or invalid values should be present
+                            // only when the thread is already shutting down due to external factors.
+                            if (s_systemEvents._windowHandle != IntPtr.Zero)
+                            {
+                                Interop.User32.PostMessageW(new HandleRef(s_systemEvents, s_systemEvents._windowHandle), Interop.User32.WM_QUIT, IntPtr.Zero, IntPtr.Zero);
+                            }
+
+                            s_windowThread.Join();
                         }
                         else
                         {
@@ -1218,6 +1222,11 @@ private IntPtr WindowProc(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam)
                     OnTimerElapsed(wParam);
                     break;
 
+                case Interop.User32.WM_DESTROY:
+                    Interop.User32.PostQuitMessage(0);
+                    _windowHandle = IntPtr.Zero;
+                    break;
+
                 default:
                     // If we received a thread execute message, then execute it.
                     if (msg == s_threadCallbackMessage && msg != 0)
@@ -1248,33 +1257,10 @@ private void WindowThreadProc()
                 {
                     Interop.User32.MSG msg = default(Interop.User32.MSG);
 
-                    bool keepRunning = true;
-
-                    // Blocking on a GetMessage() call prevents the EE from being able to unwind
-                    // this thread properly (e.g. during AppDomainUnload). So, we use PeekMessage()
-                    // and sleep so we always block in managed code instead.
-                    while (keepRunning)
+                    while (Interop.User32.GetMessageW(ref msg, _windowHandle, 0, 0) > 0)
                     {
-                        int ret = Interop.User32.MsgWaitForMultipleObjectsEx(0, IntPtr.Zero, 100, Interop.User32.QS_ALLINPUT, Interop.User32.MWMO_INPUTAVAILABLE);
-
-                        if (ret == Interop.User32.WAIT_TIMEOUT)
-                        {
-                            Thread.Sleep(1);
-                        }
-                        else
-                        {
-                            while (Interop.User32.PeekMessageW(ref msg, IntPtr.Zero, 0, 0, Interop.User32.PM_REMOVE))
-                            {
-                                if (msg.message == Interop.User32.WM_QUIT)
-                                {
-                                    keepRunning = false;
-                                    break;
-                                }
-
-                                Interop.User32.TranslateMessage(ref msg);
-                                Interop.User32.DispatchMessageW(ref msg);
-                            }
-                        }
+                        Interop.User32.TranslateMessage(ref msg);
+                        Interop.User32.DispatchMessageW(ref msg);
                     }
                 }
 
@@ -1293,10 +1279,6 @@ private void WindowThreadProc()
             }
 
             Dispose();
-            if (s_eventThreadTerminated != null)
-            {
-                s_eventThreadTerminated.Set();
-            }
         }
 
         // A class that helps fire events on the right thread.
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/tests/Microsoft.Win32.SystemEvents.Tests.csproj b/src/libraries/Microsoft.Win32.SystemEvents/tests/Microsoft.Win32.SystemEvents.Tests.csproj
index b74ffd4352b8bf..79b0db6d25a9a5 100644
--- a/src/libraries/Microsoft.Win32.SystemEvents/tests/Microsoft.Win32.SystemEvents.Tests.csproj
+++ b/src/libraries/Microsoft.Win32.SystemEvents/tests/Microsoft.Win32.SystemEvents.Tests.csproj
@@ -25,6 +25,7 @@
     <Compile Include="SystemEvents.SessionSwitch.cs" />
     <Compile Include="SystemEvents.PowerMode.cs" />
     <Compile Include="SystemEvents.TimeChanged.cs" />
+    <Compile Include="ShutdownTest.cs" />
     <Compile Include="SystemEventsTest.cs" />
     <Compile Include="SystemEvents.DisplaySettings.cs" />
     <Compile Include="SystemEvents.CreateTimer.cs" />
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/tests/ShutdownTest.cs b/src/libraries/Microsoft.Win32.SystemEvents/tests/ShutdownTest.cs
new file mode 100644
index 00000000000000..d8012da78db70b
--- /dev/null
+++ b/src/libraries/Microsoft.Win32.SystemEvents/tests/ShutdownTest.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Threading;
+using Microsoft.DotNet.RemoteExecutor;
+using Xunit;
+using static Interop;
+
+namespace Microsoft.Win32.SystemEventsTests
+{
+    public abstract class ShutdownTest : SystemEventsTest
+    {
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsNanoNorServerCore))]
+        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
+        public void ShutdownThroughRestartManager()
+        {
+            RemoteExecutor.Invoke(() =>
+            {
+                // Register any event to ensure that SystemEvents get initialized
+                SystemEvents.TimeChanged += (o, e) => { };
+
+                // Fake Restart Manager behavior by sending external WM_CLOSE message
+                SendMessage(Interop.User32.WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
+
+                // Emulate calling the Shutdown event
+                var shutdownMethod = typeof(SystemEvents).GetMethod("Shutdown", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type[0], null);
+                Assert.NotNull(shutdownMethod);
+                shutdownMethod.Invoke(null, null);
+            }).Dispose();
+        }
+    }
+}

From 519fc259a098f17a3eb30dec88cb45c666646c62 Mon Sep 17 00:00:00 2001
From: Andrii Kurdiumov <kant2002@gmail.com>
Date: Thu, 27 Jan 2022 03:42:10 +0600
Subject: [PATCH 095/161] Add marshaller for TypeLoad failure cases (#64317)

This is marshaller used when there incorrect configuration of marshaller applied to fields mostly
---
 .../TypeSystem/Interop/IL/MarshalHelpers.cs       |  7 ++++++-
 .../TypeSystem/Interop/IL/Marshaller.Aot.cs       | 15 +++++++++++++++
 .../TypeSystem/Interop/IL/MarshallerKind.cs       |  1 +
 src/tests/issues.targets                          |  6 ------
 4 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs
index b50d0406129ba6..d37f44971968b7 100644
--- a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs
@@ -95,6 +95,9 @@ internal static TypeDesc GetNativeTypeFromMarshallerKind(TypeDesc type,
                 case MarshallerKind.OleDateTime:
                     return context.GetWellKnownType(WellKnownType.Double);
 
+                case MarshallerKind.FailedTypeLoad:
+                    return context.GetWellKnownType(WellKnownType.IntPtr);
+
                 case MarshallerKind.SafeHandle:
                 case MarshallerKind.CriticalHandle:
                     return context.GetWellKnownType(WellKnownType.IntPtr);
@@ -456,7 +459,7 @@ internal static MarshallerKind GetMarshallerKind(
                     case NativeTypeKind.Array:
                         {
                             if (isField)
-                                return MarshallerKind.Invalid;
+                                return MarshallerKind.FailedTypeLoad;
 
                             var arrayType = (ArrayType)type;
 
@@ -583,6 +586,8 @@ internal static MarshallerKind GetMarshallerKind(
             }
             else if (type.IsObject)
             {
+                if (nativeType == NativeTypeKind.AsAny && isField)
+                    return MarshallerKind.FailedTypeLoad;
                 if (nativeType == NativeTypeKind.AsAny)
                     return isAnsi ? MarshallerKind.AsAnyA : MarshallerKind.AsAnyW;
                 else
diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/IL/Marshaller.Aot.cs b/src/coreclr/tools/Common/TypeSystem/Interop/IL/Marshaller.Aot.cs
index 4244a04ab1810c..01b27026152389 100644
--- a/src/coreclr/tools/Common/TypeSystem/Interop/IL/Marshaller.Aot.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Interop/IL/Marshaller.Aot.cs
@@ -86,6 +86,8 @@ protected static Marshaller CreateMarshaller(MarshallerKind kind)
                     return new OleDateTimeMarshaller();
                 case MarshallerKind.OleCurrency:
                     return new OleCurrencyMarshaller();
+                case MarshallerKind.FailedTypeLoad:
+                    return new FailedTypeLoadMarshaller();
                 case MarshallerKind.Variant:
                     return new VariantMarshaller();
                 default:
@@ -1073,6 +1075,19 @@ protected override void TransformNativeToManaged(ILCodeStream codeStream)
         }
     }
 
+    class FailedTypeLoadMarshaller : Marshaller
+    {
+        protected override void TransformManagedToNative(ILCodeStream codeStream)
+        {
+            ThrowHelper.ThrowTypeLoadException(ManagedType);
+        }
+
+        protected override void TransformNativeToManaged(ILCodeStream codeStream)
+        {
+            ThrowHelper.ThrowTypeLoadException(ManagedType);
+        }
+    }
+
     class VariantMarshaller : Marshaller
     {
         protected override void AllocManagedToNative(ILCodeStream codeStream)
diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshallerKind.cs b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshallerKind.cs
index 37d09857b694ad..888a174ff38fcc 100644
--- a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshallerKind.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshallerKind.cs
@@ -45,6 +45,7 @@ enum MarshallerKind
         LayoutClassPtr,
         AsAnyA,
         AsAnyW,
+        FailedTypeLoad,
         ComInterface,
         BlittableValueClassWithCopyCtor,
         Invalid
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index d6aa159fba256f..78089a05600769 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -920,15 +920,9 @@
         <ExcludeList Include="$(XunitTestBinBase)/Interop/NativeLibrary/Callback/CallbackTests/*">
             <Issue>https://github.com/dotnet/runtimelab/issues/206</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/Interop/PInvoke/Array/MarshalArrayAsField/AsLPArray/AsLPArrayTest/*">
-            <Issue>https://github.com/dotnet/runtimelab/issues/168</Issue>
-        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/Interop/PInvoke/Array/MarshalArrayAsParam/AsDefault/AsDefaultTest/*">
             <Issue>https://github.com/dotnet/runtimelab/issues/176: VARIANT marshalling</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/Interop/PInvoke/Array/MarshalArrayAsParam/AsLPArray/AsLPArrayTest/*">
-            <Issue>https://github.com/dotnet/runtimelab/issues/176: VARIANT marshalling</Issue>
-        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/Interop/PInvoke/ArrayWithOffset/ArrayWithOffsetTest/*">
             <Issue>https://github.com/dotnet/runtimelab/issues/170</Issue>
         </ExcludeList>

From cbc4cd873ed1f2362265e702dc7dfeaa76c5ec16 Mon Sep 17 00:00:00 2001
From: Bruce Forstall <brucefo@microsoft.com>
Date: Wed, 26 Jan 2022 14:02:18 -0800
Subject: [PATCH 096/161] Add additional loop table asserts (#64126)

1. Assert that top-level loops are basic block disjoint
2. Assert LPFLG_ITER related flags are legal

In addition:
1. Create a `optClearLoopIterInfo` phase to clear various bits in the loop
table that are known to no longer be valid, to prevent bad asserts or JitDump
output on their values.
2. Move the EndPhase call in Phase::PostPhase happens early, not late.
This causes any subsequent asserts due to post-phase checking to be
marked with the correct phase, in cases where there was a nested phase
executed (such as liveness re-computation).
3. Convert PHASE_INSERT_GC_POLLS to use EndPhase checking
4. Convert fgDetermineFirstCodeBlock to return a PhaseStatus
5. Some minor cleanup in optUpdateLoopsBeforeRemoveBlock()
(this was extracted from some bigger changes)
---
 src/coreclr/jit/compiler.cpp     | 17 +++----
 src/coreclr/jit/compiler.h       |  6 ++-
 src/coreclr/jit/compphases.h     |  5 +-
 src/coreclr/jit/earlyprop.cpp    |  2 +-
 src/coreclr/jit/fgbasic.cpp      | 10 +---
 src/coreclr/jit/fgdiagnostic.cpp | 85 ++++++++++++++++++++++++++++++--
 src/coreclr/jit/fgehopt.cpp      |  6 +--
 src/coreclr/jit/fgopt.cpp        | 30 +++++------
 src/coreclr/jit/flowgraph.cpp    | 29 +++++------
 src/coreclr/jit/lsra.cpp         |  4 ++
 src/coreclr/jit/optimizer.cpp    | 72 ++++++++++++++++-----------
 src/coreclr/jit/phase.cpp        | 40 ++++++++++-----
 12 files changed, 199 insertions(+), 107 deletions(-)

diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp
index be0c4393cab8bd..e85192d1905938 100644
--- a/src/coreclr/jit/compiler.cpp
+++ b/src/coreclr/jit/compiler.cpp
@@ -4636,7 +4636,7 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
         // Run an early flow graph simplification pass
         //
         auto earlyUpdateFlowGraphPhase = [this]() {
-            const bool doTailDup = false;
+            constexpr bool doTailDup = false;
             fgUpdateFlowGraph(doTailDup);
         };
         DoPhase(this, PHASE_EARLY_UPDATE_FLOW_GRAPH, earlyUpdateFlowGraphPhase);
@@ -4776,6 +4776,10 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
         // Unroll loops
         //
         DoPhase(this, PHASE_UNROLL_LOOPS, &Compiler::optUnrollLoops);
+
+        // Clear loop table info that is not used after this point, and might become invalid.
+        //
+        DoPhase(this, PHASE_CLEAR_LOOP_INFO, &Compiler::optClearLoopIterInfo);
     }
 
 #ifdef DEBUG
@@ -4909,7 +4913,7 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
                 // update the flowgraph if we modified it during the optimization phase
                 //
                 auto optUpdateFlowGraphPhase = [this]() {
-                    const bool doTailDup = false;
+                    constexpr bool doTailDup = false;
                     fgUpdateFlowGraph(doTailDup);
                 };
                 DoPhase(this, PHASE_OPT_UPDATE_FLOW_GRAPH, optUpdateFlowGraphPhase);
@@ -4966,11 +4970,6 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
     //
     DoPhase(this, PHASE_SIMPLE_LOWERING, &Compiler::fgSimpleLowering);
 
-#ifdef DEBUG
-    fgDebugCheckBBlist();
-    fgDebugCheckLinks();
-#endif
-
     // Enable this to gather statistical data such as
     // call and register argument info, flowgraph and loop info, etc.
     compJitStats();
@@ -5021,10 +5020,6 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl
     // Copied from rpPredictRegUse()
     SetFullPtrRegMapRequired(codeGen->GetInterruptible() || !codeGen->isFramePointerUsed());
 
-#ifdef DEBUG
-    fgDebugCheckLinks();
-#endif
-
 #if FEATURE_LOOP_ALIGN
     // Place loop alignment instructions
     DoPhase(this, PHASE_ALIGN_LOOPS, &Compiler::placeLoopAlignInstructions);
diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
index 0d4a9398481fde..6b30adbacb121d 100644
--- a/src/coreclr/jit/compiler.h
+++ b/src/coreclr/jit/compiler.h
@@ -5945,7 +5945,7 @@ class Compiler
 
     bool fgReorderBlocks();
 
-    void fgDetermineFirstColdBlock();
+    PhaseStatus fgDetermineFirstColdBlock();
 
     bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bSrc = nullptr);
 
@@ -6931,7 +6931,7 @@ class Compiler
         }
 
 #ifdef DEBUG
-        void lpValidatePreHeader()
+        void lpValidatePreHeader() const
         {
             // If this is called, we expect there to be a pre-header.
             assert(lpFlags & LPFLG_HAS_PREHEAD);
@@ -6992,6 +6992,8 @@ class Compiler
                        BasicBlock*   exit,
                        unsigned char exitCnt);
 
+    void optClearLoopIterInfo();
+
 #ifdef DEBUG
     void optPrintLoopInfo(unsigned lnum, bool printVerbose = false);
     void optPrintLoopInfo(const LoopDsc* loop, bool printVerbose = false);
diff --git a/src/coreclr/jit/compphases.h b/src/coreclr/jit/compphases.h
index e5c15c1d438a6c..8f72dcce2360cd 100644
--- a/src/coreclr/jit/compphases.h
+++ b/src/coreclr/jit/compphases.h
@@ -5,7 +5,7 @@
 //
 
 //
-// Names of x86 JIT phases, in order.  Assumes that the caller defines CompPhaseNameMacro
+// Names of JIT phases, in order.  Assumes that the caller defines CompPhaseNameMacro
 // in a useful way before including this file, e.g., to define the phase enumeration and the
 // corresponding array of string names of those phases.  This include file undefines CompPhaseNameMacro
 // after the last use.
@@ -61,6 +61,7 @@ CompPhaseNameMacro(PHASE_ZERO_INITS,             "Redundant zero Inits",
 CompPhaseNameMacro(PHASE_FIND_LOOPS,             "Find loops",                     "LOOP-FND", false, -1, false)
 CompPhaseNameMacro(PHASE_CLONE_LOOPS,            "Clone loops",                    "LP-CLONE", false, -1, false)
 CompPhaseNameMacro(PHASE_UNROLL_LOOPS,           "Unroll loops",                   "UNROLL",   false, -1, false)
+CompPhaseNameMacro(PHASE_CLEAR_LOOP_INFO,        "Clear loop info",                "LP-CLEAR", false, -1, false)
 CompPhaseNameMacro(PHASE_HOIST_LOOP_CODE,        "Hoist loop code",                "LP-HOIST", false, -1, false)
 CompPhaseNameMacro(PHASE_MARK_LOCAL_VARS,        "Mark local vars",                "MARK-LCL", false, -1, false)
 CompPhaseNameMacro(PHASE_OPTIMIZE_BOOLS,         "Optimize bools",                 "OPT-BOOL", false, -1, false)
@@ -86,7 +87,6 @@ CompPhaseNameMacro(PHASE_INSERT_GC_POLLS,        "Insert GC Polls",
 CompPhaseNameMacro(PHASE_DETERMINE_FIRST_COLD_BLOCK, "Determine first cold block", "COLD-BLK", false, -1, true)
 CompPhaseNameMacro(PHASE_RATIONALIZE,            "Rationalize IR",                 "RAT",      false, -1, false)
 CompPhaseNameMacro(PHASE_SIMPLE_LOWERING,        "Do 'simple' lowering",           "SMP-LWR",  false, -1, false)
-CompPhaseNameMacro(PHASE_ALIGN_LOOPS,            "Place 'align' instructions",     "LOOP-ALIGN",  false, -1, false)
 
 CompPhaseNameMacro(PHASE_LCLVARLIVENESS,         "Local var liveness",             "LIVENESS", true, -1, false)
 CompPhaseNameMacro(PHASE_LCLVARLIVENESS_INIT,    "Local var liveness init",        "LIV-INIT", false, PHASE_LCLVARLIVENESS, false)
@@ -100,6 +100,7 @@ CompPhaseNameMacro(PHASE_LINEAR_SCAN,            "Linear scan register alloc",
 CompPhaseNameMacro(PHASE_LINEAR_SCAN_BUILD,      "LSRA build intervals",           "LSRA-BLD", false, PHASE_LINEAR_SCAN, false)
 CompPhaseNameMacro(PHASE_LINEAR_SCAN_ALLOC,      "LSRA allocate",                  "LSRA-ALL", false, PHASE_LINEAR_SCAN, false)
 CompPhaseNameMacro(PHASE_LINEAR_SCAN_RESOLVE,    "LSRA resolve",                   "LSRA-RES", false, PHASE_LINEAR_SCAN, false)
+CompPhaseNameMacro(PHASE_ALIGN_LOOPS,            "Place 'align' instructions",     "LOOP-ALIGN",  false, -1, false)
 CompPhaseNameMacro(PHASE_GENERATE_CODE,          "Generate code",                  "CODEGEN",  false, -1, false)
 CompPhaseNameMacro(PHASE_EMIT_CODE,              "Emit code",                      "EMIT",     false, -1, false)
 CompPhaseNameMacro(PHASE_EMIT_GCEH,              "Emit GC+EH tables",              "EMT-GCEH", false, -1, false)
diff --git a/src/coreclr/jit/earlyprop.cpp b/src/coreclr/jit/earlyprop.cpp
index f00b3f6e3ad6e6..283c9c8901ae7c 100644
--- a/src/coreclr/jit/earlyprop.cpp
+++ b/src/coreclr/jit/earlyprop.cpp
@@ -110,7 +110,7 @@ void Compiler::optCheckFlagsAreSet(unsigned    methodFlag,
     if ((basicBlock->bbFlags & bbFlag) == 0)
     {
         printf("%s is not set on " FMT_BB " but is required because of the following tree \n", bbFlagStr,
-               compCurBB->bbNum);
+               basicBlock->bbNum);
         gtDispTree(tree);
         assert(false);
     }
diff --git a/src/coreclr/jit/fgbasic.cpp b/src/coreclr/jit/fgbasic.cpp
index 6b41c055422b0b..6725fc1f2bfe9c 100644
--- a/src/coreclr/jit/fgbasic.cpp
+++ b/src/coreclr/jit/fgbasic.cpp
@@ -4552,7 +4552,7 @@ void Compiler::fgRemoveBlock(BasicBlock* block, bool unreachable)
 
     BasicBlock* bPrev = block->bbPrev;
 
-    JITDUMP("fgRemoveBlock " FMT_BB "\n", block->bbNum);
+    JITDUMP("fgRemoveBlock " FMT_BB ", unreachable=%s\n", block->bbNum, dspBool(unreachable));
 
     // If we've cached any mappings from switch blocks to SwitchDesc's (which contain only the
     // *unique* successors of the switch block), invalidate that cache, since an entry in one of
@@ -4576,12 +4576,6 @@ void Compiler::fgRemoveBlock(BasicBlock* block, bool unreachable)
 
         fgUnreachableBlock(block);
 
-        /* If this is the last basic block update fgLastBB */
-        if (block == fgLastBB)
-        {
-            fgLastBB = bPrev;
-        }
-
 #if defined(FEATURE_EH_FUNCLETS)
         // If block was the fgFirstFuncletBB then set fgFirstFuncletBB to block->bbNext
         if (block == fgFirstFuncletBB)
@@ -4634,7 +4628,7 @@ void Compiler::fgRemoveBlock(BasicBlock* block, bool unreachable)
             leaveBlk->bbRefs  = 0;
             leaveBlk->bbPreds = nullptr;
 
-            fgRemoveBlock(leaveBlk, true);
+            fgRemoveBlock(leaveBlk, /* unreachable */ true);
 
 #if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
             fgClearFinallyTargetBit(leaveBlk->bbJumpDest);
diff --git a/src/coreclr/jit/fgdiagnostic.cpp b/src/coreclr/jit/fgdiagnostic.cpp
index 0bc461ebbb9495..2df6d000419b9e 100644
--- a/src/coreclr/jit/fgdiagnostic.cpp
+++ b/src/coreclr/jit/fgdiagnostic.cpp
@@ -3534,12 +3534,22 @@ void Compiler::fgDebugCheckNodesUniqueness()
 //    - If the method has natural loops, the loop table is not null
 //    - Loop `top` must come before `bottom`.
 //    - Loop `entry` must be between `top` and `bottom`.
+//    - Children loops of a loop are disjoint.
 //    - All basic blocks with loop numbers set have a corresponding loop in the table
 //    - All basic blocks without a loop number are not in a loop
 //    - All parents of the loop with the block contain that block
+//    - If the loop has a pre-header, it is valid
+//    - The loop flags are valid
 //
 void Compiler::fgDebugCheckLoopTable()
 {
+#ifdef DEBUG
+    if (verbose)
+    {
+        printf("*************** In fgDebugCheckLoopTable\n");
+    }
+#endif // DEBUG
+
     if (optLoopCount > 0)
     {
         assert(optLoopTable != nullptr);
@@ -3655,8 +3665,38 @@ void Compiler::fgDebugCheckLoopTable()
             assert(loop.lpExit == nullptr);
         }
 
-        if (loop.lpParent != BasicBlock::NOT_IN_LOOP)
+        if (loop.lpParent == BasicBlock::NOT_IN_LOOP)
         {
+            // This is a top-level loop.
+
+            // Verify all top-level loops are disjoint. We don't have a list of just these (such as a
+            // top-level pseudo-loop entry with a list of all top-level lists), so we have to iterate
+            // over the entire loop table.
+            for (unsigned j = 0; j < optLoopCount; j++)
+            {
+                if (i == j)
+                {
+                    // Don't compare against ourselves.
+                    continue;
+                }
+                const LoopDsc& otherLoop = optLoopTable[j];
+                if (otherLoop.lpFlags & LPFLG_REMOVED)
+                {
+                    continue;
+                }
+                if (otherLoop.lpParent != BasicBlock::NOT_IN_LOOP)
+                {
+                    // Only consider top-level loops
+                    continue;
+                }
+                assert(MappedChecks::lpDisjoint(blockNumMap, &loop, otherLoop));
+            }
+        }
+        else
+        {
+            // This is not a top-level loop
+
+            assert(loop.lpParent != BasicBlock::NOT_IN_LOOP);
             assert(loop.lpParent < optLoopCount);
             assert(loop.lpParent < i); // outer loops come before inner loops in the table
             const LoopDsc& parentLoop = optLoopTable[loop.lpParent];
@@ -3674,10 +3714,12 @@ void Compiler::fgDebugCheckLoopTable()
                 assert(child < optLoopCount);
                 assert(i < child); // outer loops come before inner loops in the table
                 const LoopDsc& childLoop = optLoopTable[child];
-                if ((childLoop.lpFlags & LPFLG_REMOVED) == 0) // removed child loop might still be in table
+                if (childLoop.lpFlags & LPFLG_REMOVED) // removed child loop might still be in table
                 {
-                    assert(MappedChecks::lpContains(blockNumMap, &loop, childLoop));
+                    continue;
                 }
+                assert(MappedChecks::lpContains(blockNumMap, &loop, childLoop));
+                assert(childLoop.lpParent == i);
             }
 
             // Verify all child loops are disjoint.
@@ -3734,6 +3776,43 @@ void Compiler::fgDebugCheckLoopTable()
                     assert(MappedChecks::lpContains(blockNumMap, &loop, predBlock));
                 }
             }
+
+            loop.lpValidatePreHeader();
+        }
+
+        // Check the flags.
+        // Note that the various init/limit flags are only used when LPFLG_ITER is set, but they are set first,
+        // separately, and only if everything works out is LPFLG_ITER set. If LPFLG_ITER is NOT set, the
+        // individual flags are not un-set (arguably, they should be).
+
+        // Only one of the `init` flags can be set.
+        assert(genCountBits((unsigned)(loop.lpFlags & (LPFLG_VAR_INIT | LPFLG_CONST_INIT))) <= 1);
+
+        // Only one of the `limit` flags can be set. (Note that LPFLG_SIMD_LIMIT is a "sub-flag" that can be
+        // set when LPFLG_CONST_LIMIT is set.)
+        assert(genCountBits((unsigned)(loop.lpFlags & (LPFLG_VAR_LIMIT | LPFLG_CONST_LIMIT | LPFLG_ARRLEN_LIMIT))) <=
+               1);
+
+        // LPFLG_SIMD_LIMIT can only be set if LPFLG_CONST_LIMIT is set.
+        if (loop.lpFlags & LPFLG_SIMD_LIMIT)
+        {
+            assert(loop.lpFlags & LPFLG_CONST_LIMIT);
+        }
+
+        if (loop.lpFlags & (LPFLG_CONST_INIT | LPFLG_VAR_INIT))
+        {
+            assert(loop.lpInitBlock != nullptr);
+
+            if (loop.lpFlags & LPFLG_VAR_INIT)
+            {
+                assert(loop.lpVarInit < lvaCount);
+            }
+        }
+
+        if (loop.lpFlags & LPFLG_ITER)
+        {
+            loop.VERIFY_lpIterTree();
+            loop.VERIFY_lpTestTree();
         }
     }
 
diff --git a/src/coreclr/jit/fgehopt.cpp b/src/coreclr/jit/fgehopt.cpp
index 4fa511f63dbddb..514b6879a9f6b3 100644
--- a/src/coreclr/jit/fgehopt.cpp
+++ b/src/coreclr/jit/fgehopt.cpp
@@ -175,7 +175,7 @@ PhaseStatus Compiler::fgRemoveEmptyFinally()
                 nextBlock = leaveBlock->bbNext;
 
                 leaveBlock->bbFlags &= ~BBF_KEEP_BBJ_ALWAYS;
-                fgRemoveBlock(leaveBlock, true);
+                fgRemoveBlock(leaveBlock, /* unreachable */ true);
 
                 // Cleanup the postTryFinallyBlock
                 fgCleanupContinuation(postTryFinallyBlock);
@@ -194,8 +194,8 @@ PhaseStatus Compiler::fgRemoveEmptyFinally()
         firstBlock->bbRefs = 0;
 
         // Remove the handler block.
-        const bool unreachable = true;
         firstBlock->bbFlags &= ~BBF_DONT_REMOVE;
+        constexpr bool unreachable = true;
         fgRemoveBlock(firstBlock, unreachable);
 
         // Find enclosing try region for the try, if any, and update
@@ -1181,7 +1181,7 @@ PhaseStatus Compiler::fgCloneFinally()
                         nextBlock = leaveBlock->bbNext;
 
                         leaveBlock->bbFlags &= ~BBF_KEEP_BBJ_ALWAYS;
-                        fgRemoveBlock(leaveBlock, true);
+                        fgRemoveBlock(leaveBlock, /* unreachable */ true);
 
                         // Make sure iteration isn't going off the deep end.
                         assert(leaveBlock != endCallFinallyRangeBlock);
diff --git a/src/coreclr/jit/fgopt.cpp b/src/coreclr/jit/fgopt.cpp
index 4e446837bcb189..eebe8a8e8eff5c 100644
--- a/src/coreclr/jit/fgopt.cpp
+++ b/src/coreclr/jit/fgopt.cpp
@@ -445,8 +445,7 @@ bool Compiler::fgRemoveUnreachableBlocks()
         else if (block == genReturnBB)
         {
             // Don't remove statements for the genReturnBB block, as we might have special hookups there.
-            // For example, <BUGNUM> in VSW 364383, </BUGNUM>
-            // the profiler hookup needs to have the "void GT_RETURN" statement
+            // For example, the profiler hookup needs to have the "void GT_RETURN" statement
             // to properly set the info.compProfilerCallback flag.
             continue;
         }
@@ -478,10 +477,9 @@ bool Compiler::fgRemoveUnreachableBlocks()
 
         if (block->bbFlags & BBF_DONT_REMOVE)
         {
-            bool bIsBBCallAlwaysPair = block->isBBCallAlwaysPair();
+            const bool bIsBBCallAlwaysPair = block->isBBCallAlwaysPair();
 
-            /* Unmark the block as removed, */
-            /* clear BBF_INTERNAL as well and set BBJ_IMPORTED */
+            // Unmark the block as removed, clear BBF_INTERNAL, and set BBJ_IMPORTED
 
             // The successors may be unreachable after this change.
             changed |= block->NumSucc() > 0;
@@ -518,7 +516,7 @@ bool Compiler::fgRemoveUnreachableBlocks()
 
             if (block->bbFlags & BBF_REMOVED)
             {
-                fgRemoveBlock(block, true);
+                fgRemoveBlock(block, /* unreachable */ true);
 
                 // TODO: couldn't we have fgRemoveBlock() return the block after the (last)one removed
                 // so we don't need the code below?
@@ -2285,8 +2283,7 @@ void Compiler::fgUnreachableBlock(BasicBlock* block)
 {
     // genReturnBB should never be removed, as we might have special hookups there.
     // Therefore, we should never come here to remove the statements in the genReturnBB block.
-    // For example, <BUGNUM> in VSW 364383, </BUGNUM>
-    // the profiler hookup needs to have the "void GT_RETURN" statement
+    // For example, the profiler hookup needs to have the "void GT_RETURN" statement
     // to properly set the info.compProfilerCallback flag.
     noway_assert(block != genReturnBB);
 
@@ -2308,10 +2305,7 @@ void Compiler::fgUnreachableBlock(BasicBlock* block)
     assert(!block->isBBCallAlwaysPairTail()); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
 #endif
 
-    /* First walk the statement trees in this basic block and delete each stmt */
-
-    /* Make the block publicly available */
-    compCurBB = block;
+    // First, delete all the code in the block.
 
     if (block->IsLIR())
     {
@@ -2343,13 +2337,13 @@ void Compiler::fgUnreachableBlock(BasicBlock* block)
         noway_assert(block->bbStmtList == nullptr);
     }
 
-    /* Next update the loop table and bbWeights */
+    // Next update the loop table and bbWeights
     optUpdateLoopsBeforeRemoveBlock(block);
 
-    /* Mark the block as removed */
+    // Mark the block as removed
     block->bbFlags |= BBF_REMOVED;
 
-    /* update bbRefs and bbPreds for the blocks reached by this block */
+    // Update bbRefs and bbPreds for the blocks reached by this block
     fgRemoveBlockAsPred(block);
 }
 
@@ -2825,7 +2819,7 @@ bool Compiler::fgOptimizeEmptyBlock(BasicBlock* block)
 
             /* Remove the block */
             compCurBB = block;
-            fgRemoveBlock(block, false);
+            fgRemoveBlock(block, /* unreachable */ false);
             return true;
 
         default:
@@ -6108,7 +6102,7 @@ bool Compiler::fgUpdateFlowGraph(bool doTailDuplication)
                 /* no references -> unreachable - remove it */
                 /* For now do not update the bbNum, do it at the end */
 
-                fgRemoveBlock(block, true);
+                fgRemoveBlock(block, /* unreachable */ true);
 
                 change   = true;
                 modified = true;
@@ -6126,7 +6120,7 @@ bool Compiler::fgUpdateFlowGraph(bool doTailDuplication)
                     case BBJ_ALWAYS:
                         if (block->bbJumpDest == block)
                         {
-                            fgRemoveBlock(block, true);
+                            fgRemoveBlock(block, /* unreachable */ true);
 
                             change   = true;
                             modified = true;
diff --git a/src/coreclr/jit/flowgraph.cpp b/src/coreclr/jit/flowgraph.cpp
index 21f0f583340a8f..e2786ce57d820d 100644
--- a/src/coreclr/jit/flowgraph.cpp
+++ b/src/coreclr/jit/flowgraph.cpp
@@ -67,7 +67,6 @@ static bool blockNeedsGCPoll(BasicBlock* block)
 // Returns:
 //    PhaseStatus indicating what, if anything, was changed.
 //
-
 PhaseStatus Compiler::fgInsertGCPolls()
 {
     PhaseStatus result = PhaseStatus::MODIFIED_NOTHING;
@@ -181,13 +180,6 @@ PhaseStatus Compiler::fgInsertGCPolls()
         constexpr bool computeDoms  = false;
         fgUpdateChangedFlowGraph(computePreds, computeDoms);
     }
-#ifdef DEBUG
-    if (verbose)
-    {
-        printf("*************** After fgInsertGCPolls()\n");
-        fgDispBasicBlocks(true);
-    }
-#endif // DEBUG
 
     return result;
 }
@@ -3093,6 +3085,9 @@ void Compiler::fgSimpleLowering()
         fgDispHandlerTab();
         printf("\n");
     }
+
+    fgDebugCheckBBlist();
+    fgDebugCheckLinks();
 #endif
 }
 
@@ -3374,7 +3369,7 @@ void Compiler::fgCreateFunclets()
  * or are rarely executed.
  */
 
-void Compiler::fgDetermineFirstColdBlock()
+PhaseStatus Compiler::fgDetermineFirstColdBlock()
 {
 #ifdef DEBUG
     if (verbose)
@@ -3388,19 +3383,19 @@ void Compiler::fgDetermineFirstColdBlock()
     //
     assert(fgSafeBasicBlockCreation);
 
-    fgFirstColdBlock = nullptr;
+    assert(fgFirstColdBlock == nullptr);
 
     if (!opts.compProcedureSplitting)
     {
         JITDUMP("No procedure splitting will be done for this method\n");
-        return;
+        return PhaseStatus::MODIFIED_NOTHING;
     }
 
 #ifdef DEBUG
     if ((compHndBBtabCount > 0) && !opts.compProcedureSplittingEH)
     {
         JITDUMP("No procedure splitting will be done for this method with EH (by request)\n");
-        return;
+        return PhaseStatus::MODIFIED_NOTHING;
     }
 #endif // DEBUG
 
@@ -3411,7 +3406,7 @@ void Compiler::fgDetermineFirstColdBlock()
     if (compHndBBtabCount > 0)
     {
         JITDUMP("No procedure splitting will be done for this method with EH (implementation limitation)\n");
-        return;
+        return PhaseStatus::MODIFIED_NOTHING;
     }
 #endif // FEATURE_EH_FUNCLETS
 
@@ -3482,7 +3477,7 @@ void Compiler::fgDetermineFirstColdBlock()
 
         if (prevToFirstColdBlock == nullptr)
         {
-            return; // To keep Prefast happy
+            return PhaseStatus::MODIFIED_EVERYTHING; // To keep Prefast happy
         }
 
         // If we only have one cold block
@@ -3578,14 +3573,12 @@ EXIT:;
         {
             printf("fgFirstColdBlock is NULL.\n");
         }
-
-        fgDispBasicBlocks();
     }
-
-    fgVerifyHandlerTab();
 #endif // DEBUG
 
     fgFirstColdBlock = firstColdBlock;
+
+    return PhaseStatus::MODIFIED_EVERYTHING;
 }
 
 /* static */
diff --git a/src/coreclr/jit/lsra.cpp b/src/coreclr/jit/lsra.cpp
index f1e97f9692d9ab..88f137ab65764d 100644
--- a/src/coreclr/jit/lsra.cpp
+++ b/src/coreclr/jit/lsra.cpp
@@ -1299,6 +1299,10 @@ void LinearScan::doLinearScan()
 
     DBEXEC(VERBOSE, TupleStyleDump(LSRA_DUMP_POST));
 
+#ifdef DEBUG
+    compiler->fgDebugCheckLinks();
+#endif
+
     compiler->compLSRADone = true;
 }
 
diff --git a/src/coreclr/jit/optimizer.cpp b/src/coreclr/jit/optimizer.cpp
index d633a6d84aecd1..dd2f3a8246ede1 100644
--- a/src/coreclr/jit/optimizer.cpp
+++ b/src/coreclr/jit/optimizer.cpp
@@ -402,16 +402,14 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
 
     bool removeLoop = false;
 
-    /* If an unreachable block was part of a loop entry or bottom then the loop is unreachable */
-    /* Special case: the block was the head of a loop - or pointing to a loop entry */
+    // If an unreachable block is a loop entry or bottom then the loop is unreachable.
+    // Special case: the block was the head of a loop - or pointing to a loop entry.
 
     for (unsigned loopNum = 0; loopNum < optLoopCount; loopNum++)
     {
         LoopDsc& loop = optLoopTable[loopNum];
 
-        /* Some loops may have been already removed by
-         * loop unrolling or conditional folding */
-
+        // Some loops may have been already removed by loop unrolling or conditional folding.
         if (loop.lpFlags & LPFLG_REMOVED)
         {
             continue;
@@ -454,11 +452,9 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
             continue;
         }
 
-        /* If the loop is still in the table
-         * any block in the loop must be reachable !!! */
+        // If the loop is still in the table any block in the loop must be reachable.
 
-        noway_assert(loop.lpEntry != block);
-        noway_assert(loop.lpBottom != block);
+        noway_assert((loop.lpEntry != block) && (loop.lpBottom != block));
 
         if (loop.lpExit == block)
         {
@@ -468,27 +464,26 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
             loop.lpExit = nullptr;
         }
 
-        /* If this points to the actual entry in the loop
-         * then the whole loop may become unreachable */
+        // If `block` flows to the loop entry then the whole loop will become unreachable if it is the
+        // only non-loop predecessor.
 
         switch (block->bbJumpKind)
         {
             case BBJ_NONE:
-            case BBJ_COND:
                 if (block->bbNext == loop.lpEntry)
                 {
                     removeLoop = true;
-                    break;
                 }
-                if (block->bbJumpKind == BBJ_NONE)
+                break;
+
+            case BBJ_COND:
+                if ((block->bbNext == loop.lpEntry) || (block->bbJumpDest == loop.lpEntry))
                 {
-                    break;
+                    removeLoop = true;
                 }
-
-                FALLTHROUGH;
+                break;
 
             case BBJ_ALWAYS:
-                noway_assert(block->bbJumpDest);
                 if (block->bbJumpDest == loop.lpEntry)
                 {
                     removeLoop = true;
@@ -512,13 +507,12 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
 
         if (removeLoop)
         {
-            /* Check if the entry has other predecessors outside the loop
-             * TODO: Replace this when predecessors are available */
+            // Check if the entry has other predecessors outside the loop.
+            // TODO: Replace this when predecessors are available.
 
             for (BasicBlock* const auxBlock : Blocks())
             {
-                /* Ignore blocks in the loop */
-
+                // Ignore blocks in the loop.
                 if (loop.lpContains(auxBlock))
                 {
                     continue;
@@ -527,21 +521,20 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
                 switch (auxBlock->bbJumpKind)
                 {
                     case BBJ_NONE:
-                    case BBJ_COND:
                         if (auxBlock->bbNext == loop.lpEntry)
                         {
                             removeLoop = false;
-                            break;
                         }
-                        if (auxBlock->bbJumpKind == BBJ_NONE)
+                        break;
+
+                    case BBJ_COND:
+                        if ((auxBlock->bbNext == loop.lpEntry) || (auxBlock->bbJumpDest == loop.lpEntry))
                         {
-                            break;
+                            removeLoop = false;
                         }
-
-                        FALLTHROUGH;
+                        break;
 
                     case BBJ_ALWAYS:
-                        noway_assert(auxBlock->bbJumpDest);
                         if (auxBlock->bbJumpDest == loop.lpEntry)
                         {
                             removeLoop = false;
@@ -592,6 +585,27 @@ void Compiler::optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmar
     }
 }
 
+//------------------------------------------------------------------------
+// optClearLoopIterInfo: Clear the info related to LPFLG_ITER loops in the loop table.
+// The various fields related to iterators is known to be valid for loop cloning and unrolling,
+// but becomes invalid afterwards. Clear the info that might be used incorrectly afterwards
+// in JitDump or by subsequent phases.
+//
+void Compiler::optClearLoopIterInfo()
+{
+    for (unsigned lnum = 0; lnum < optLoopCount; lnum++)
+    {
+        LoopDsc& loop = optLoopTable[lnum];
+        loop.lpFlags &= ~(LPFLG_ITER | LPFLG_VAR_INIT | LPFLG_CONST_INIT | LPFLG_SIMD_LIMIT | LPFLG_VAR_LIMIT |
+                          LPFLG_CONST_LIMIT | LPFLG_ARRLEN_LIMIT);
+
+        loop.lpIterTree  = nullptr;
+        loop.lpInitBlock = nullptr;
+        loop.lpConstInit = -1; // union with loop.lpVarInit
+        loop.lpTestTree  = nullptr;
+    }
+}
+
 #ifdef DEBUG
 
 /*****************************************************************************
diff --git a/src/coreclr/jit/phase.cpp b/src/coreclr/jit/phase.cpp
index f08134bf11532b..7bcc372cb0cf82 100644
--- a/src/coreclr/jit/phase.cpp
+++ b/src/coreclr/jit/phase.cpp
@@ -141,6 +141,8 @@ void Phase::PrePhase()
 //
 void Phase::PostPhase(PhaseStatus status)
 {
+    comp->EndPhase(m_phase);
+
 #ifdef DEBUG
 
     // Don't dump or check post phase unless the phase made changes.
@@ -162,16 +164,32 @@ void Phase::PostPhase(PhaseStatus status)
     // well as the new-style phases that have been updated to return
     // PhaseStatus from their DoPhase methods.
     //
-    static Phases s_allowlist[] = {PHASE_IMPORTATION,      PHASE_IBCINSTR,
-                                   PHASE_IBCPREP,          PHASE_INCPROFILE,
-                                   PHASE_INDXCALL,         PHASE_MORPH_INLINE,
-                                   PHASE_ALLOCATE_OBJECTS, PHASE_EMPTY_TRY,
-                                   PHASE_EMPTY_FINALLY,    PHASE_MERGE_FINALLY_CHAINS,
-                                   PHASE_CLONE_FINALLY,    PHASE_MERGE_THROWS,
-                                   PHASE_MORPH_GLOBAL,     PHASE_INVERT_LOOPS,
-                                   PHASE_OPTIMIZE_LAYOUT,  PHASE_FIND_LOOPS,
-                                   PHASE_BUILD_SSA,        PHASE_RATIONALIZE,
-                                   PHASE_LOWERING,         PHASE_STACK_LEVEL_SETTER};
+    // clang-format off
+
+    static Phases s_allowlist[] = {
+        PHASE_IMPORTATION,
+        PHASE_IBCINSTR,
+        PHASE_IBCPREP,
+        PHASE_INCPROFILE,
+        PHASE_INDXCALL,
+        PHASE_MORPH_INLINE,
+        PHASE_ALLOCATE_OBJECTS,
+        PHASE_EMPTY_TRY,
+        PHASE_EMPTY_FINALLY,
+        PHASE_MERGE_FINALLY_CHAINS,
+        PHASE_CLONE_FINALLY,
+        PHASE_MERGE_THROWS,
+        PHASE_MORPH_GLOBAL,
+        PHASE_INVERT_LOOPS,
+        PHASE_OPTIMIZE_LAYOUT,
+        PHASE_FIND_LOOPS,
+        PHASE_BUILD_SSA,
+        PHASE_INSERT_GC_POLLS,
+        PHASE_RATIONALIZE,
+        PHASE_LOWERING,
+        PHASE_STACK_LEVEL_SETTER};
+
+    // clang-format on
 
     if (madeChanges)
     {
@@ -234,6 +252,4 @@ void Phase::PostPhase(PhaseStatus status)
 #if DUMP_FLOWGRAPHS
     comp->fgDumpFlowGraph(m_phase, Compiler::PhasePosition::PostPhase);
 #endif // DUMP_FLOWGRAPHS
-
-    comp->EndPhase(m_phase);
 }

From 2cf48266341bafa60006ee2cd0f5696d63bb8151 Mon Sep 17 00:00:00 2001
From: Vladimir Sadov <vsadov@microsoft.com>
Date: Wed, 26 Jan 2022 14:51:07 -0800
Subject: [PATCH 097/161] Moved AssemblyName helpers to managed (part 2)
 (#63915)

* implement GetAssemblyName via dynamic call to MetadataReader

* A few more file-locking tests.

* fix #28153

* no need for version when getting MetadataReader

* rename the argument to match AssemblyName

* perf tweaks

* use memory-mapped file to read metadata

* adjust tests for the new implementation

* use "bufferSize: 1" when stream is going to be mapped.

* null-conditional operator.

* do Dispose before re-throwing

* get rid of the platform-specific/native stuff

* remove assemblyname.hpp

* remove `VerifyIsAssembly()`

* PR feedback

* put back gStdMngIEnumerableFuncs and the others
---
 .../System/Reflection/AssemblyName.CoreCLR.cs | 11 ---
 .../src/System.Private.CoreLib.csproj         |  1 -
 .../System/Reflection/AssemblyName.CoreRT.cs  | 15 ----
 .../Compiler/CompilerTypeSystemContext.cs     | 11 ++-
 .../SymbolReader/PortablePdbSymbolReader.cs   | 11 ++-
 .../dotnet-pgo/TraceTypeSystemContext.cs      | 11 ++-
 src/coreclr/vm/CMakeLists.txt                 |  2 -
 src/coreclr/vm/appdomain.cpp                  |  1 -
 src/coreclr/vm/assembly.cpp                   |  3 -
 src/coreclr/vm/assemblyname.cpp               | 69 -------------------
 src/coreclr/vm/assemblyname.hpp               | 25 -------
 src/coreclr/vm/assemblynative.cpp             |  1 -
 src/coreclr/vm/corelib.cpp                    |  1 -
 src/coreclr/vm/ecalllist.h                    |  5 --
 src/coreclr/vm/peimage.cpp                    | 28 --------
 src/coreclr/vm/peimage.h                      |  2 -
 src/coreclr/vm/qcallentrypoints.cpp           |  1 -
 .../AppHost/HostWriter.cs                     |  2 +-
 .../Hosting/AssemblyCatalogTests.cs           | 19 ++---
 .../src/System/Reflection/AssemblyName.cs     | 27 ++++++--
 .../Metadata/MetadataReader.netstandard.cs    | 53 +++++++++++++-
 .../TypeSystem/AssemblyDefinitionTests.cs     |  4 +-
 .../TypeSystem/AssemblyReferenceTests.cs      |  4 +-
 .../tests/AssemblyNameTests.cs                | 11 +--
 .../src/ILLink/ILLink.Descriptors.xml         |  1 -
 .../src/System/Reflection/Assembly.Mono.cs    |  3 -
 .../System/Reflection/AssemblyName.Mono.cs    | 19 -----
 src/mono/mono/metadata/icall-def-netcore.h    |  1 -
 src/mono/mono/metadata/icall.c                | 54 ---------------
 29 files changed, 100 insertions(+), 296 deletions(-)
 delete mode 100644 src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs
 delete mode 100644 src/coreclr/vm/assemblyname.cpp
 delete mode 100644 src/coreclr/vm/assemblyname.hpp

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs
index 0a3cd42ba900a5..bfe5bcce8db998 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs
@@ -32,17 +32,6 @@ internal AssemblyName(string? name,
             _flags = flags;
         }
 
-        // This call opens and closes the file, but does not add the
-        // assembly to the domain.
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern AssemblyName nGetFileInformation(string s);
-
-        internal static AssemblyName GetFileInformationCore(string assemblyFile)
-        {
-            string fullPath = Path.GetFullPath(assemblyFile);
-            return nGetFileInformation(fullPath);
-        }
-
         internal void SetProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm)
         {
 #pragma warning disable SYSLIB0037 // AssemblyName.ProcessorArchitecture is obsolete
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj b/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj
index bc79d83f0d4768..2284e13f661357 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj
@@ -129,7 +129,6 @@
     <Compile Include="System\Reflection\AssemblyRuntimeNameHelpers.cs" />
     <Compile Include="System\Reflection\Attribute.CoreRT.cs" />
     <Compile Include="System\Reflection\Assembly.CoreRT.cs" />
-    <Compile Include="System\Reflection\AssemblyName.CoreRT.cs" />
     <Compile Include="System\Reflection\BinderBundle.cs" />
     <Compile Include="System\Reflection\Emit\AssemblyBuilder.cs" />
     <Compile Include="System\Reflection\Emit\ConstructorBuilder.cs" />
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs
deleted file mode 100644
index 7efcf64288a621..00000000000000
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreRT.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.Serialization;
-
-namespace System.Reflection
-{
-    public sealed partial class AssemblyName : ICloneable, IDeserializationCallback, ISerializable
-    {
-        private static AssemblyName GetFileInformationCore(string assemblyFile)
-        {
-            throw new PlatformNotSupportedException(SR.PlatformNotSupported_AssemblyName_GetAssemblyName);
-        }
-    }
-}
diff --git a/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.cs b/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.cs
index fa0828fc034e86..029949cda38468 100644
--- a/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.cs
+++ b/src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.cs
@@ -157,7 +157,7 @@ public static unsafe PEReader OpenPEFile(string filePath, out MemoryMappedViewAc
             try
             {
                 // Create stream because CreateFromFile(string, ...) uses FileShare.None which is too strict
-                fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, false);
+                fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 1);
                 mappedFile = MemoryMappedFile.CreateFromFile(
                     fileStream, null, fileStream.Length, MemoryMappedFileAccess.Read, HandleInheritability.None, true);
                 accessor = mappedFile.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read);
@@ -174,12 +174,9 @@ public static unsafe PEReader OpenPEFile(string filePath, out MemoryMappedViewAc
             }
             finally
             {
-                if (accessor != null)
-                    accessor.Dispose();
-                if (mappedFile != null)
-                    mappedFile.Dispose();
-                if (fileStream != null)
-                    fileStream.Dispose();
+                accessor?.Dispose();
+                mappedFile?.Dispose();
+                fileStream?.Dispose();
             }
         }
 
diff --git a/src/coreclr/tools/Common/TypeSystem/Ecma/SymbolReader/PortablePdbSymbolReader.cs b/src/coreclr/tools/Common/TypeSystem/Ecma/SymbolReader/PortablePdbSymbolReader.cs
index 5d8d4fd0f4c2b5..b270b73ab8d90b 100644
--- a/src/coreclr/tools/Common/TypeSystem/Ecma/SymbolReader/PortablePdbSymbolReader.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Ecma/SymbolReader/PortablePdbSymbolReader.cs
@@ -26,7 +26,7 @@ private static unsafe MetadataReader TryOpenMetadataFile(string filePath, Metada
             try
             {
                 // Create stream because CreateFromFile(string, ...) uses FileShare.None which is too strict
-                fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, false);
+                fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 1);
                 mappedFile = MemoryMappedFile.CreateFromFile(
                     fileStream, null, fileStream.Length, MemoryMappedFileAccess.Read, HandleInheritability.None, true);
 
@@ -56,12 +56,9 @@ private static unsafe MetadataReader TryOpenMetadataFile(string filePath, Metada
             }
             finally
             {
-                if (accessor != null)
-                    accessor.Dispose();
-                if (mappedFile != null)
-                    mappedFile.Dispose();
-                if (fileStream != null)
-                    fileStream.Dispose();
+                accessor?.Dispose();
+                mappedFile?.Dispose();
+                fileStream?.Dispose();
             }
         }
 
diff --git a/src/coreclr/tools/dotnet-pgo/TraceTypeSystemContext.cs b/src/coreclr/tools/dotnet-pgo/TraceTypeSystemContext.cs
index 09e2f52ea053aa..afdb148089b266 100644
--- a/src/coreclr/tools/dotnet-pgo/TraceTypeSystemContext.cs
+++ b/src/coreclr/tools/dotnet-pgo/TraceTypeSystemContext.cs
@@ -260,7 +260,7 @@ public static unsafe PEReader OpenPEFile(string filePath, byte[] moduleBytes, ou
             try
             {
                 // Create stream because CreateFromFile(string, ...) uses FileShare.None which is too strict
-                fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, false);
+                fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 1);
                 mappedFile = MemoryMappedFile.CreateFromFile(
                     fileStream, null, fileStream.Length, MemoryMappedFileAccess.Read, HandleInheritability.None, true);
                 accessor = mappedFile.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read);
@@ -278,12 +278,9 @@ public static unsafe PEReader OpenPEFile(string filePath, byte[] moduleBytes, ou
             }
             finally
             {
-                if (accessor != null)
-                    accessor.Dispose();
-                if (mappedFile != null)
-                    mappedFile.Dispose();
-                if (fileStream != null)
-                    fileStream.Dispose();
+                accessor?.Dispose();
+                mappedFile?.Dispose();
+                fileStream?.Dispose();
             }
         }
 
diff --git a/src/coreclr/vm/CMakeLists.txt b/src/coreclr/vm/CMakeLists.txt
index 2f34d2c0ceaa17..e063b7ad3677c2 100644
--- a/src/coreclr/vm/CMakeLists.txt
+++ b/src/coreclr/vm/CMakeLists.txt
@@ -289,7 +289,6 @@ set(GC_HEADERS_DAC
 set(VM_SOURCES_WKS
     ${VM_SOURCES_DAC_AND_WKS_COMMON}
     appdomainnative.cpp
-    assemblyname.cpp
     assemblynative.cpp
     assemblyspec.cpp
     baseassemblyspec.cpp
@@ -392,7 +391,6 @@ set(VM_HEADERS_WKS
     ${VM_HEADERS_DAC_AND_WKS_COMMON}
     ../inc/jithelpers.h
     appdomainnative.hpp
-    assemblyname.hpp
     assemblynative.hpp
     assemblyspec.hpp
     assemblyspecbase.h
diff --git a/src/coreclr/vm/appdomain.cpp b/src/coreclr/vm/appdomain.cpp
index 0194f960809d92..2aa55d6d5128fb 100644
--- a/src/coreclr/vm/appdomain.cpp
+++ b/src/coreclr/vm/appdomain.cpp
@@ -11,7 +11,6 @@
 #include "eeconfig.h"
 #include "gcheaputilities.h"
 #include "eventtrace.h"
-#include "assemblyname.hpp"
 #include "eeprofinterfaces.h"
 #include "dbginterface.h"
 #ifndef DACCESS_COMPILE
diff --git a/src/coreclr/vm/assembly.cpp b/src/coreclr/vm/assembly.cpp
index 9176b757b88582..6a2ff15250ddc8 100644
--- a/src/coreclr/vm/assembly.cpp
+++ b/src/coreclr/vm/assembly.cpp
@@ -17,9 +17,6 @@
 
 #include "assembly.hpp"
 #include "appdomain.hpp"
-#include "assemblyname.hpp"
-
-
 
 #include "eeprofinterfaces.h"
 #include "reflectclasswriter.h"
diff --git a/src/coreclr/vm/assemblyname.cpp b/src/coreclr/vm/assemblyname.cpp
deleted file mode 100644
index 8cf625cad095d7..00000000000000
--- a/src/coreclr/vm/assemblyname.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-/*============================================================
-**
-** Header:  AssemblyName.cpp
-**
-** Purpose: Implements AssemblyName (loader domain) architecture
-**
-**
-
-
-**
-===========================================================*/
-
-#include "common.h"
-
-#include <stdlib.h>
-#include <shlwapi.h>
-
-#include "assemblyname.hpp"
-#include "field.h"
-#include "strongnameholders.h"
-#include "strongnameinternal.h"
-#include "eeconfig.h"
-
-FCIMPL1(Object*, AssemblyNameNative::GetFileInformation, StringObject* filenameUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    struct _gc
-    {
-        ASSEMBLYNAMEREF result;
-        STRINGREF       filename;
-    } gc;
-
-    gc.result   = NULL;
-    gc.filename = (STRINGREF) filenameUNSAFE;
-
-    HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
-
-    if (gc.filename == NULL)
-        COMPlusThrow(kArgumentNullException, W("ArgumentNull_FileName"));
-
-    if (gc.filename->GetStringLength() == 0)
-        COMPlusThrow(kArgumentException, W("Argument_EmptyFileName"));
-
-    gc.result = (ASSEMBLYNAMEREF) AllocateObject(CoreLibBinder::GetClass(CLASS__ASSEMBLY_NAME));
-
-
-    ///////////////////////////////////////////////
-    SString sFileName(gc.filename->GetBuffer());
-    PEImageHolder pImage = PEImage::OpenImage(sFileName, MDInternalImport_NoCache);
-
-    // Ask for FLAT. We will only look at metadata and release the image shortly.
-    // Besides we may be getting the assembly name for images that contain native code for a
-    // non-native platform and would end up using flat anyways.
-    PEImageLayout* pLayout = pImage->GetOrCreateLayout(PEImageLayout::LAYOUT_FLAT);
-
-    pImage->VerifyIsAssembly();
-
-    AssemblySpec spec;
-    spec.InitializeSpec(TokenFromRid(1,mdtAssembly),pImage->GetMDImport(),NULL);
-    spec.AssemblyNameInit(&gc.result, pImage);
-
-    HELPER_METHOD_FRAME_END();
-    return OBJECTREFToObject(gc.result);
-}
-FCIMPLEND
diff --git a/src/coreclr/vm/assemblyname.hpp b/src/coreclr/vm/assemblyname.hpp
deleted file mode 100644
index a336cfaf9ae701..00000000000000
--- a/src/coreclr/vm/assemblyname.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-/*============================================================
-**
-** Header:  AssemblyName.hpp
-**
-** Purpose: Implements AssemblyName (loader domain) architecture
-**
-**
-
-
-**
-===========================================================*/
-#ifndef _AssemblyName_H
-#define _AssemblyName_H
-
-class AssemblyNameNative
-{
-public:
-    static FCDECL1(Object*, GetFileInformation, StringObject* filenameUNSAFE);
-};
-
-#endif  // _AssemblyName_H
-
diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp
index 19a5d62c0b9ed0..fcb7af91bb6bf5 100644
--- a/src/coreclr/vm/assemblynative.cpp
+++ b/src/coreclr/vm/assemblynative.cpp
@@ -20,7 +20,6 @@
 #include "assemblynative.hpp"
 #include "dllimport.h"
 #include "field.h"
-#include "assemblyname.hpp"
 #include "eeconfig.h"
 #include "interoputil.h"
 #include "frames.h"
diff --git a/src/coreclr/vm/corelib.cpp b/src/coreclr/vm/corelib.cpp
index 707cd24274148b..54bb5177cae530 100644
--- a/src/coreclr/vm/corelib.cpp
+++ b/src/coreclr/vm/corelib.cpp
@@ -32,7 +32,6 @@
 #include "comdatetime.h"
 #include "compatibilityswitch.h"
 #include "debugdebugger.h"
-#include "assemblyname.hpp"
 #include "assemblynative.hpp"
 #include "comthreadpool.h"
 #include "comwaithandle.h"
diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
index 8a11c4fb930ab8..08ab8e71c868a4 100644
--- a/src/coreclr/vm/ecalllist.h
+++ b/src/coreclr/vm/ecalllist.h
@@ -291,10 +291,6 @@ FCFuncStart(gAssemblyLoadContextFuncs)
     FCFuncElement("IsTracingEnabled", AssemblyNative::IsTracingEnabled)
 FCFuncEnd()
 
-FCFuncStart(gAssemblyNameFuncs)
-    FCFuncElement("nGetFileInformation", AssemblyNameNative::GetFileInformation)
-FCFuncEnd()
-
 FCFuncStart(gAssemblyBuilderFuncs)
     FCFuncElement("GetInMemoryAssemblyModule", AssemblyNative::GetInMemoryAssemblyModule)
 FCFuncEnd()
@@ -768,7 +764,6 @@ FCClassElement("ArgIterator", "System", gVarArgFuncs)
 FCClassElement("Array", "System", gArrayFuncs)
 FCClassElement("AssemblyBuilder", "System.Reflection.Emit", gAssemblyBuilderFuncs)
 FCClassElement("AssemblyLoadContext", "System.Runtime.Loader", gAssemblyLoadContextFuncs)
-FCClassElement("AssemblyName", "System.Reflection", gAssemblyNameFuncs)
 FCClassElement("Buffer", "System", gBufferFuncs)
 FCClassElement("CastHelpers", "System.Runtime.CompilerServices", gCastHelpers)
 FCClassElement("CompatibilitySwitch", "System.Runtime.Versioning", gCompatibilitySwitchFuncs)
diff --git a/src/coreclr/vm/peimage.cpp b/src/coreclr/vm/peimage.cpp
index 1b72b89106df65..946943cc3cd612 100644
--- a/src/coreclr/vm/peimage.cpp
+++ b/src/coreclr/vm/peimage.cpp
@@ -456,34 +456,6 @@ void PEImage::GetMVID(GUID *pMvid)
 #endif // _DEBUG
 }
 
-void PEImage::VerifyIsAssembly()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // buch of legacy stuff here wrt the error codes...
-
-    if (!HasNTHeaders())
-        ThrowFormat(COR_E_BADIMAGEFORMAT);
-
-    if(!HasCorHeader())
-        ThrowFormat(COR_E_ASSEMBLYEXPECTED);
-
-    CHECK checkGoodFormat;
-    checkGoodFormat = CheckILFormat();
-    if (!checkGoodFormat)
-        ThrowFormat(COR_E_BADIMAGEFORMAT);
-
-    mdAssembly a;
-    if (FAILED(GetMDImport()->GetAssemblyFromScope(&a)))
-        ThrowFormat(COR_E_ASSEMBLYEXPECTED);
-}
-
 void DECLSPEC_NORETURN PEImage::ThrowFormat(HRESULT hrError)
 {
     CONTRACTL
diff --git a/src/coreclr/vm/peimage.h b/src/coreclr/vm/peimage.h
index 6451283d007ce4..f353cebe978d14 100644
--- a/src/coreclr/vm/peimage.h
+++ b/src/coreclr/vm/peimage.h
@@ -182,8 +182,6 @@ class PEImage final
     CHECK CheckILFormat();
     CHECK CheckUniqueInstance();
 
-    void VerifyIsAssembly();
-
     void SetModuleFileNameHintForDAC();
 #ifdef DACCESS_COMPILE
     void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp
index 96971b81801951..2d5d1cfc92b37c 100644
--- a/src/coreclr/vm/qcallentrypoints.cpp
+++ b/src/coreclr/vm/qcallentrypoints.cpp
@@ -27,7 +27,6 @@
 #include "comdatetime.h"
 #include "compatibilityswitch.h"
 #include "debugdebugger.h"
-#include "assemblyname.hpp"
 #include "assemblynative.hpp"
 #include "comthreadpool.h"
 #include "comwaithandle.h"
diff --git a/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs b/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs
index f17bbbe6378ccc..e1e81da93ff4d5 100644
--- a/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs
+++ b/src/installer/managed/Microsoft.NET.HostModel/AppHost/HostWriter.cs
@@ -94,7 +94,7 @@ void UpdateResources()
                     try
                     {
                         // Open the source host file.
-                        appHostSourceStream = new FileStream(appHostSourceFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+                        appHostSourceStream = new FileStream(appHostSourceFilePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 1);
                         memoryMappedFile = MemoryMappedFile.CreateFromFile(appHostSourceStream, null, 0, MemoryMappedFileAccess.Read, HandleInheritability.None, true);
                         memoryMappedViewAccessor = memoryMappedFile.CreateViewAccessor(0, 0, MemoryMappedFileAccess.CopyOnWrite);
 
diff --git a/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/Hosting/AssemblyCatalogTests.cs b/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/Hosting/AssemblyCatalogTests.cs
index 333dd8e473bb6d..712637375d096e 100644
--- a/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/Hosting/AssemblyCatalogTests.cs
+++ b/src/libraries/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/Hosting/AssemblyCatalogTests.cs
@@ -84,19 +84,12 @@ internal static void Constructor_ValueAsCodebaseArgument_ShouldSetAssemblyProper
             }
         }
 
-        internal static void Constructor_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad(Func<string, AssemblyCatalog> catalogCreator)
+        internal static void Constructor_LockedFileAsCodeBaseArgument_ShouldThrowIOException(Func<string, AssemblyCatalog> catalogCreator)
         {
             string filename = Path.GetTempFileName();
             using (FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.None))
             {
-                if (PlatformDetection.IsWindows) // File locking is Windows specific.
-                {
-                    Assert.Throws<FileLoadException>(() => catalogCreator(filename));
-                }
-                else
-                {
-                    Assert.Throws<BadImageFormatException>(() => catalogCreator(filename));
-                }
+                Assert.Throws<System.IO.IOException>(() => catalogCreator(filename));
             }
         }
 
@@ -184,7 +177,7 @@ public void Constructor1_ValueAsCodebaseArgument_ShouldSetAssemblyProperty()
         [Fact]
         public void Constructor1_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad()
         {
-            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad((s) =>
+            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowIOException((s) =>
             {
                 return new AssemblyCatalog(s);
             });
@@ -294,7 +287,7 @@ public void Constructor2_ValueAsCodebaseArgument_ShouldSetAssemblyProperty()
         [Fact]
         public void Constructor2_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad()
         {
-            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad((s) =>
+            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowIOException((s) =>
             {
                 return new AssemblyCatalog(s, new AssemblyCatalogTestsReflectionContext());
             });
@@ -403,7 +396,7 @@ public void Constructor3_ValueAsCodebaseArgument_ShouldSetAssemblyProperty()
         [Fact]
         public void Constructor3_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad()
         {
-            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad((s) =>
+            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowIOException((s) =>
             {
                 return new AssemblyCatalog(s, (ICompositionElement)new AssemblyCatalog(s));
             });
@@ -511,7 +504,7 @@ public void Constructor4_ValueAsCodebaseArgument_ShouldSetAssemblyProperty()
         [Fact]
         public void Constructor4_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad()
         {
-            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowFileLoad((s) =>
+            AssemblyCatalogConstructorTests.Constructor_LockedFileAsCodeBaseArgument_ShouldThrowIOException((s) =>
             {
                 return new AssemblyCatalog(s, new AssemblyCatalogTestsReflectionContext(), (ICompositionElement)new AssemblyCatalog(s));
             });
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs
index a1822fbe83a1ac..5594d4fdef7f22 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs
@@ -162,6 +162,28 @@ public object Clone()
             return name;
         }
 
+        private static Func<string, AssemblyName>? s_getAssemblyName;
+        private static Func<string, AssemblyName> InitGetAssemblyName()
+        {
+            Type? readerType = Type.GetType(
+                    "System.Reflection.Metadata.MetadataReader, System.Reflection.Metadata",
+                    throwOnError: true);
+
+            MethodInfo? getAssemblyNameMethod = readerType!.GetMethod(
+                "GetAssemblyName",
+                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static,
+                null,
+                new Type[] { typeof(string) },
+                null);
+
+            if (getAssemblyNameMethod == null)
+            {
+                throw new MissingMethodException(readerType.FullName, "GetAssemblyName");
+            }
+
+            return s_getAssemblyName = getAssemblyNameMethod.CreateDelegate<Func<string, AssemblyName>>();
+        }
+
         /*
          * Get the AssemblyName for a given file. This will only work
          * if the file contains an assembly manifest. This method causes
@@ -169,10 +191,7 @@ public object Clone()
          */
         public static AssemblyName GetAssemblyName(string assemblyFile)
         {
-            if (assemblyFile == null)
-                throw new ArgumentNullException(nameof(assemblyFile));
-
-            return GetFileInformationCore(assemblyFile);
+            return (s_getAssemblyName ?? InitGetAssemblyName())(assemblyFile);
         }
 
         public byte[]? GetPublicKey()
diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/MetadataReader.netstandard.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/MetadataReader.netstandard.cs
index a4e71b93171a62..6cdac1a324b58f 100644
--- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/MetadataReader.netstandard.cs
+++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/MetadataReader.netstandard.cs
@@ -1,6 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO;
+using System.IO.MemoryMappedFiles;
+using System.Reflection.PortableExecutable;
+using Microsoft.Win32.SafeHandles;
+
 namespace System.Reflection.Metadata
 {
     public sealed partial class MetadataReader
@@ -8,7 +13,8 @@ public sealed partial class MetadataReader
         internal AssemblyName GetAssemblyName(StringHandle nameHandle, Version version, StringHandle cultureHandle, BlobHandle publicKeyOrTokenHandle, AssemblyHashAlgorithm assemblyHashAlgorithm, AssemblyFlags flags)
         {
             string name = GetString(nameHandle);
-            string? cultureName = (!cultureHandle.IsNil) ? GetString(cultureHandle) : null;
+            // compat: normalize 'null' culture name to "" to match AssemblyName.GetAssemblyName()
+            string cultureName = (!cultureHandle.IsNil) ? GetString(cultureHandle) : "";
             var hashAlgorithm = (Configuration.Assemblies.AssemblyHashAlgorithm)assemblyHashAlgorithm;
             byte[]? publicKeyOrToken = !publicKeyOrTokenHandle.IsNil ? GetBlobBytes(publicKeyOrTokenHandle) : null;
 
@@ -36,6 +42,51 @@ internal AssemblyName GetAssemblyName(StringHandle nameHandle, Version version,
             return assemblyName;
         }
 
+        internal static unsafe AssemblyName GetAssemblyName(string assemblyFile)
+        {
+            if (assemblyFile == null)
+                throw new ArgumentNullException(nameof(assemblyFile));
+
+            FileStream? fileStream = null;
+            MemoryMappedFile? mappedFile = null;
+            MemoryMappedViewAccessor? accessor = null;
+            PEReader? peReader = null;
+
+            try
+            {
+                try
+                {
+                    // Create stream because CreateFromFile(string, ...) uses FileShare.None which is too strict
+                    fileStream = new FileStream(assemblyFile, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 1, useAsync: false);
+                    if (fileStream.Length == 0)
+                    {
+                        throw new BadImageFormatException(SR.PEImageDoesNotHaveMetadata, assemblyFile);
+                    }
+
+                    mappedFile = MemoryMappedFile.CreateFromFile(
+                        fileStream, null, fileStream.Length, MemoryMappedFileAccess.Read, HandleInheritability.None, true);
+                    accessor = mappedFile.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read);
+
+                    SafeMemoryMappedViewHandle? safeBuffer = accessor.SafeMemoryMappedViewHandle;
+                    peReader = new PEReader((byte*)safeBuffer.DangerousGetHandle(), (int)safeBuffer.ByteLength);
+                    MetadataReader mdReader = peReader.GetMetadataReader(MetadataReaderOptions.None);
+                    AssemblyName assemblyName = mdReader.GetAssemblyDefinition().GetAssemblyName();
+                    return assemblyName;
+                }
+                finally
+                {
+                    peReader?.Dispose();
+                    accessor?.Dispose();
+                    mappedFile?.Dispose();
+                    fileStream?.Dispose();
+                }
+            }
+            catch (InvalidOperationException ex)
+            {
+                throw new BadImageFormatException(ex.Message);
+            }
+        }
+
         private AssemblyNameFlags GetAssemblyNameFlags(AssemblyFlags flags)
         {
             AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
diff --git a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyDefinitionTests.cs b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyDefinitionTests.cs
index 9b940dcfa4be83..b54b3f855af0b4 100644
--- a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyDefinitionTests.cs
+++ b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyDefinitionTests.cs
@@ -55,7 +55,7 @@ public void ValidateAssemblyNameWithPublicKey()
                 Assert.Equal(assembly.Version, assemblyName.Version);
                 Assert.Equal(assembly.Name, assemblyName.Name);
                 Assert.Equal(assembly.ContentType, assemblyName.ContentType);
-                Assert.Null(assemblyName.CultureName);
+                Assert.Equal("", assemblyName.CultureName);
                 Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.SHA1, assemblyName.HashAlgorithm);
                 Assert.Equal(assembly.Flags, assemblyName.Flags);
                 Assert.NotNull(assemblyName.GetPublicKeyToken());
@@ -94,7 +94,7 @@ public void ValidateAssemblyNameForAssemblyDefinition()
                     Assert.Equal(item.Version, assemblyName.Version);
                     Assert.Equal(item.Name, assemblyName.Name);
                     Assert.Equal(item.ContentType, assemblyName.ContentType);
-                    Assert.Null(assemblyName.CultureName);
+                    Assert.Equal("", assemblyName.CultureName);
                     Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.SHA1, assemblyName.HashAlgorithm);
                     Assert.Null(assemblyName.GetPublicKey());
                     Assert.Null(assemblyName.GetPublicKeyToken());
diff --git a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyReferenceTests.cs b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyReferenceTests.cs
index 8da72d74e59ada..801d546722a39b 100644
--- a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyReferenceTests.cs
+++ b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeSystem/AssemblyReferenceTests.cs
@@ -21,7 +21,7 @@ public void ValidateAssemblyNameForSingleAssemblyReference()
             Assert.Equal("System.Runtime", assemblyName.Name);
             Assert.Equal(new Version(4, 0, 0, 0), assemblyName.Version);
             Assert.Equal(new byte[] { 0xB0, 0x3F, 0x5F, 0x7F, 0x11, 0xD5, 0x0A, 0x3A }, assemblyName.GetPublicKeyToken());
-            Assert.Null(assemblyName.CultureName);
+            Assert.Equal("",assemblyName.CultureName);
             Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.None, assemblyName.HashAlgorithm);
             Assert.Null(assemblyName.GetPublicKey());
             Assert.Equal(AssemblyNameFlags.None, assemblyName.Flags);
@@ -70,7 +70,7 @@ public void ValidateAssemblyNameForMultipleAssemblyReferences()
                 Assert.Equal(expRefs[i], assemblyName.Name);
                 Assert.Equal(expVers[i], assemblyName.Version);
                 Assert.Equal(expKeys[i], assemblyName.GetPublicKeyToken());
-                Assert.Null(assemblyName.CultureName);
+                Assert.Equal("",assemblyName.CultureName);
                 Assert.Equal(Configuration.Assemblies.AssemblyHashAlgorithm.None, assemblyName.HashAlgorithm);
                 Assert.Null(assemblyName.GetPublicKey());
                 Assert.Equal(AssemblyNameFlags.None, assemblyName.Flags);
diff --git a/src/libraries/System.Reflection/tests/AssemblyNameTests.cs b/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
index 34a7023e2e6078..60ce4be8e8d7ce 100644
--- a/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
+++ b/src/libraries/System.Reflection/tests/AssemblyNameTests.cs
@@ -309,20 +309,13 @@ public static void GetAssemblyName()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/34492", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
+        [SkipOnPlatform(TestPlatforms.Browser, "File locking is not respected")]
         public static void GetAssemblyName_LockedFile()
         {
             using (var tempFile = new TempFile(Path.GetTempFileName(), 100))
             using (var fileStream = new FileStream(tempFile.Path, FileMode.Append, FileAccess.Write, FileShare.None))
             {
-                if (PlatformDetection.IsWindows) // File locking is Windows specific.
-                {
-                    Assert.Throws<System.IO.FileLoadException>(() => AssemblyName.GetAssemblyName(tempFile.Path));
-                }
-                else
-                {
-                    Assert.Throws<System.BadImageFormatException>(() => AssemblyName.GetAssemblyName(tempFile.Path));
-                }
+                Assert.Throws<System.IO.IOException>(() => AssemblyName.GetAssemblyName(tempFile.Path));
             }
         }
 
diff --git a/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.xml b/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.xml
index 2f578bdf50ab68..b5f129a8faa840 100644
--- a/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.xml
+++ b/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.xml
@@ -424,7 +424,6 @@
 			* ves_icall_System_Reflection_Assembly_GetReferencedAssemblies
 			* fill_reflection_assembly_name
 				* ves_icall_System_Reflection_Assembly_FillName
-				* ves_icall_System_Reflection_Assembly_InternalGetAssemblyName
 				* ves_icall_System_Reflection_AssemblyName_ParseName
 			-->
 		<type fullname="System.Version">
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Assembly.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Assembly.Mono.cs
index 7f48f693a2f190..e59446b10a0d4e 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Assembly.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Assembly.Mono.cs
@@ -95,8 +95,5 @@ internal static uint GetAssemblyCount()
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal extern Type InternalGetType(Module? module, string name, bool throwOnError, bool ignoreCase);
-
-        [MethodImplAttribute(MethodImplOptions.InternalCall)]
-        internal static extern void InternalGetAssemblyName(string assemblyFile, out Mono.MonoAssemblyName aname, out string codebase);
     }
 }
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
index 67ff341eec5df9..fe9a331f861454 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/AssemblyName.Mono.cs
@@ -78,25 +78,6 @@ internal unsafe void FillName(MonoAssemblyName* native, string? codeBase, bool a
             }
         }
 
-        private static AssemblyName GetFileInformationCore(string assemblyFile)
-        {
-            unsafe
-            {
-                Assembly.InternalGetAssemblyName(Path.GetFullPath(assemblyFile), out MonoAssemblyName nativeName, out string? codebase);
-
-                var aname = new AssemblyName();
-                try
-                {
-                    aname.FillName(&nativeName, codebase, true, false, true);
-                    return aname;
-                }
-                finally
-                {
-                    RuntimeMarshal.FreeAssemblyName(ref nativeName, false);
-                }
-            }
-        }
-
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern unsafe MonoAssemblyName* GetNativeName(IntPtr assemblyPtr);
     }
diff --git a/src/mono/mono/metadata/icall-def-netcore.h b/src/mono/mono/metadata/icall-def-netcore.h
index ae7984fada9b04..b26f5cc8fec63f 100644
--- a/src/mono/mono/metadata/icall-def-netcore.h
+++ b/src/mono/mono/metadata/icall-def-netcore.h
@@ -170,7 +170,6 @@ ICALL_TYPE(ASSEM, "System.Reflection.Assembly", ASSEM_2)
 HANDLES(ASSEM_2, "GetCallingAssembly", ves_icall_System_Reflection_Assembly_GetCallingAssembly, MonoReflectionAssembly, 0, ())
 HANDLES(ASSEM_3, "GetEntryAssemblyNative", ves_icall_System_Reflection_Assembly_GetEntryAssembly, MonoReflectionAssembly, 0, ())
 HANDLES(ASSEM_4, "GetExecutingAssembly", ves_icall_System_Reflection_Assembly_GetExecutingAssembly, MonoReflectionAssembly, 1, (MonoStackCrawlMark_ptr))
-HANDLES(ASSEM_5, "InternalGetAssemblyName", ves_icall_System_Reflection_Assembly_InternalGetAssemblyName, void, 3, (MonoString, MonoAssemblyName_ref, MonoStringOut))
 HANDLES(ASSEM_6, "InternalGetType", ves_icall_System_Reflection_Assembly_InternalGetType, MonoReflectionType, 5, (MonoReflectionAssembly, MonoReflectionModule, MonoString, MonoBoolean, MonoBoolean))
 HANDLES(ASSEM_7, "InternalLoad", ves_icall_System_Reflection_Assembly_InternalLoad, MonoReflectionAssembly, 3, (MonoString, MonoStackCrawlMark_ptr, gpointer))
 
diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c
index 92e0526e1c2b4c..8bd911b7830aa8 100644
--- a/src/mono/mono/metadata/icall.c
+++ b/src/mono/mono/metadata/icall.c
@@ -4990,60 +4990,6 @@ ves_icall_System_Reflection_AssemblyName_GetNativeName (MonoAssembly *mass)
 	return &mass->aname;
 }
 
-void
-ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoStringHandle fname, MonoAssemblyName *name, MonoStringHandleOut normalized_codebase, MonoError *error)
-{
-	char *filename;
-	MonoImageOpenStatus status = MONO_IMAGE_OK;
-	char *codebase = NULL;
-	gboolean res;
-	MonoImage *image;
-
-	filename = mono_string_handle_to_utf8 (fname, error);
-	return_if_nok (error);
-
-	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_ASSEMBLY, "InternalGetAssemblyName (\"%s\")", filename);
-
-	MonoAssemblyLoadContext *alc = mono_alc_get_default ();
-	image = mono_image_open_a_lot (alc, filename, &status);
-
-	if (!image){
-		if (status == MONO_IMAGE_IMAGE_INVALID)
-			mono_error_set_bad_image_by_name (error, filename, "Invalid Image: %s", filename);
-		else
-			mono_error_set_simple_file_not_found (error, filename);
-		g_free (filename);
-		return;
-	}
-
-	res = mono_assembly_fill_assembly_name_full (image, name, TRUE);
-	if (!res) {
-		mono_image_close (image);
-		g_free (filename);
-		mono_error_set_argument (error, "assemblyFile", "The file does not contain a manifest");
-		return;
-	}
-
-	if (filename != NULL && *filename != '\0') {
-		gchar *result;
-
-		codebase = g_strdup (filename);
-
-		mono_icall_make_platform_path (codebase);
-
-		const gchar *prepend = mono_icall_get_file_path_prefix (codebase);
-
-		result = g_strconcat (prepend, codebase, (const char*)NULL);
-		g_free (codebase);
-		codebase = result;
-	}
-	MONO_HANDLE_ASSIGN (normalized_codebase, mono_string_new_handle (codebase, error));
-	g_free (codebase);
-
-	mono_image_close (image);
-	g_free (filename);
-}
-
 static gboolean
 mono_module_type_is_visible (MonoTableInfo *tdef, MonoImage *image, int type)
 {

From c0d481fecb23e166d1eff180ed3b20fcbe402875 Mon Sep 17 00:00:00 2001
From: madelson <1269046+madelson@users.noreply.github.com>
Date: Wed, 26 Jan 2022 18:28:59 -0500
Subject: [PATCH 098/161] Fix several bugs in NullabilityInfoContext. (#64143)

* Fix several bugs in NullabilityInfoContext.
---
 .../Reflection/NullabilityInfoContext.cs      | 303 ++++++++++++------
 .../Reflection/NullabilityInfoContextTests.cs | 176 ++++++++--
 2 files changed, 359 insertions(+), 120 deletions(-)

diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs
index b58e03aeb6e44f..1a87dc84ee96bd 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/NullabilityInfoContext.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 
 namespace System.Reflection
 {
@@ -27,7 +28,7 @@ private enum NotAnnotatedStatus
             Internal = 0x2 // internal members not annotated
         }
 
-        private NullabilityState GetNullableContext(MemberInfo? memberInfo)
+        private NullabilityState? GetNullableContext(MemberInfo? memberInfo)
         {
             while (memberInfo != null)
             {
@@ -51,7 +52,7 @@ private NullabilityState GetNullableContext(MemberInfo? memberInfo)
                 memberInfo = memberInfo.DeclaringType;
             }
 
-            return NullabilityState.Unknown;
+            return null;
         }
 
         /// <summary>
@@ -71,13 +72,11 @@ public NullabilityInfo Create(ParameterInfo parameterInfo)
 
             EnsureIsSupported();
 
-            if (parameterInfo.Member is MethodInfo method && IsPrivateOrInternalMethodAndAnnotationDisabled(method))
-            {
-                return new NullabilityInfo(parameterInfo.ParameterType, NullabilityState.Unknown, NullabilityState.Unknown, null, Array.Empty<NullabilityInfo>());
-            }
-
             IList<CustomAttributeData> attributes = parameterInfo.GetCustomAttributesData();
-            NullabilityInfo nullability = GetNullabilityInfo(parameterInfo.Member, parameterInfo.ParameterType, attributes);
+            NullableAttributeStateParser parser = parameterInfo.Member is MethodBase method && IsPrivateOrInternalMethodAndAnnotationDisabled(method)
+                ? NullableAttributeStateParser.Unknown
+                : CreateParser(attributes);
+            NullabilityInfo nullability = GetNullabilityInfo(parameterInfo.Member, parameterInfo.ParameterType, parser);
 
             if (nullability.ReadState != NullabilityState.Unknown)
             {
@@ -114,7 +113,7 @@ private void CheckParameterMetadataType(ParameterInfo parameter, NullabilityInfo
 
                 if (metaParameter != null)
                 {
-                    CheckGenericParameters(nullability, metaMethod, metaParameter.ParameterType);
+                    CheckGenericParameters(nullability, metaMethod, metaParameter.ParameterType, parameter.Member.ReflectedType);
                 }
             }
         }
@@ -131,40 +130,45 @@ private static MethodInfo GetMethodMetadataDefinition(MethodInfo method)
 
         private void CheckNullabilityAttributes(NullabilityInfo nullability, IList<CustomAttributeData> attributes)
         {
+            var codeAnalysisReadState = NullabilityState.Unknown;
+            var codeAnalysisWriteState = NullabilityState.Unknown;
+
             foreach (CustomAttributeData attribute in attributes)
             {
                 if (attribute.AttributeType.Namespace == "System.Diagnostics.CodeAnalysis")
                 {
-                    if (attribute.AttributeType.Name == "NotNullAttribute" &&
-                        nullability.ReadState == NullabilityState.Nullable)
+                    if (attribute.AttributeType.Name == "NotNullAttribute")
                     {
-                        nullability.ReadState = NullabilityState.NotNull;
-                        break;
+                        codeAnalysisReadState = NullabilityState.NotNull;
                     }
                     else if ((attribute.AttributeType.Name == "MaybeNullAttribute" ||
                             attribute.AttributeType.Name == "MaybeNullWhenAttribute") &&
-                            nullability.ReadState == NullabilityState.NotNull &&
+                            codeAnalysisReadState == NullabilityState.Unknown &&
                             !nullability.Type.IsValueType)
                     {
-                        nullability.ReadState = NullabilityState.Nullable;
-                        break;
+                        codeAnalysisReadState = NullabilityState.Nullable;
                     }
-
-                    if (attribute.AttributeType.Name == "DisallowNullAttribute" &&
-                        nullability.WriteState == NullabilityState.Nullable)
+                    else if (attribute.AttributeType.Name == "DisallowNullAttribute")
                     {
-                        nullability.WriteState = NullabilityState.NotNull;
-                        break;
+                        codeAnalysisWriteState = NullabilityState.NotNull;
                     }
                     else if (attribute.AttributeType.Name == "AllowNullAttribute" &&
-                        nullability.WriteState == NullabilityState.NotNull &&
+                        codeAnalysisWriteState == NullabilityState.Unknown &&
                         !nullability.Type.IsValueType)
                     {
-                        nullability.WriteState = NullabilityState.Nullable;
-                        break;
+                        codeAnalysisWriteState = NullabilityState.Nullable;
                     }
                 }
             }
+
+            if (codeAnalysisReadState != NullabilityState.Unknown)
+            {
+                nullability.ReadState = codeAnalysisReadState;
+            }
+            if (codeAnalysisWriteState != NullabilityState.Unknown)
+            {
+                nullability.WriteState = codeAnalysisWriteState;
+            }
         }
 
         /// <summary>
@@ -184,17 +188,15 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
             EnsureIsSupported();
 
-            NullabilityInfo nullability = GetNullabilityInfo(propertyInfo, propertyInfo.PropertyType, propertyInfo.GetCustomAttributesData());
             MethodInfo? getter = propertyInfo.GetGetMethod(true);
             MethodInfo? setter = propertyInfo.GetSetMethod(true);
+            bool annotationsDisabled = (getter == null || IsPrivateOrInternalMethodAndAnnotationDisabled(getter))
+                && (setter == null || IsPrivateOrInternalMethodAndAnnotationDisabled(setter));
+            NullableAttributeStateParser parser = annotationsDisabled ? NullableAttributeStateParser.Unknown : CreateParser(propertyInfo.GetCustomAttributesData());
+            NullabilityInfo nullability = GetNullabilityInfo(propertyInfo, propertyInfo.PropertyType, parser);
 
             if (getter != null)
             {
-                if (IsPrivateOrInternalMethodAndAnnotationDisabled(getter))
-                {
-                    nullability.ReadState = NullabilityState.Unknown;
-                }
-
                 CheckNullabilityAttributes(nullability, getter.ReturnParameter.GetCustomAttributesData());
             }
             else
@@ -204,12 +206,7 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
 
             if (setter != null)
             {
-                if (IsPrivateOrInternalMethodAndAnnotationDisabled(setter))
-                {
-                    nullability.WriteState = NullabilityState.Unknown;
-                }
-
-                CheckNullabilityAttributes(nullability, setter.GetParameters()[0].GetCustomAttributesData());
+                CheckNullabilityAttributes(nullability, setter.GetParameters()[^1].GetCustomAttributesData());
             }
             else
             {
@@ -219,7 +216,7 @@ public NullabilityInfo Create(PropertyInfo propertyInfo)
             return nullability;
         }
 
-        private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodInfo method)
+        private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodBase method)
         {
             if ((method.IsPrivate || method.IsFamilyAndAssembly || method.IsAssembly) &&
                IsPublicOnly(method.IsPrivate, method.IsFamilyAndAssembly, method.IsAssembly, method.Module))
@@ -247,7 +244,7 @@ public NullabilityInfo Create(EventInfo eventInfo)
 
             EnsureIsSupported();
 
-            return GetNullabilityInfo(eventInfo, eventInfo.EventHandlerType!, eventInfo.GetCustomAttributesData());
+            return GetNullabilityInfo(eventInfo, eventInfo.EventHandlerType!, CreateParser(eventInfo.GetCustomAttributesData()));
         }
 
         /// <summary>
@@ -267,13 +264,9 @@ public NullabilityInfo Create(FieldInfo fieldInfo)
 
             EnsureIsSupported();
 
-            if (IsPrivateOrInternalFieldAndAnnotationDisabled(fieldInfo))
-            {
-                return new NullabilityInfo(fieldInfo.FieldType, NullabilityState.Unknown, NullabilityState.Unknown, null, Array.Empty<NullabilityInfo>());
-            }
-
             IList<CustomAttributeData> attributes = fieldInfo.GetCustomAttributesData();
-            NullabilityInfo nullability = GetNullabilityInfo(fieldInfo, fieldInfo.FieldType, attributes);
+            NullableAttributeStateParser parser = IsPrivateOrInternalFieldAndAnnotationDisabled(fieldInfo) ? NullableAttributeStateParser.Unknown : CreateParser(attributes);
+            NullabilityInfo nullability = GetNullabilityInfo(fieldInfo, fieldInfo.FieldType, parser);
             CheckNullabilityAttributes(nullability, attributes);
             return nullability;
         }
@@ -341,13 +334,13 @@ private NotAnnotatedStatus PopulateAnnotationInfo(IList<CustomAttributeData> cus
             return NotAnnotatedStatus.None;
         }
 
-        private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, IList<CustomAttributeData> customAttributes)
+        private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, NullableAttributeStateParser parser)
         {
             int index = 0;
-            return GetNullabilityInfo(memberInfo, type, customAttributes, ref index);
+            return GetNullabilityInfo(memberInfo, type, parser, ref index);
         }
 
-        private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, IList<CustomAttributeData> customAttributes, ref int index)
+        private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, NullableAttributeStateParser parser, ref int index)
         {
             NullabilityState state = NullabilityState.Unknown;
             NullabilityInfo? elementState = null;
@@ -370,19 +363,20 @@ private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, ILi
 
                 if (underlyingType.IsGenericType)
                 {
-                    index++;
+                    ++index;
                 }
             }
             else
             {
-                if (!ParseNullableState(customAttributes, index++, ref state))
+                if (!parser.ParseNullableState(index++, ref state)
+                    && GetNullableContext(memberInfo) is { } contextState)
                 {
-                    state = GetNullableContext(memberInfo);
+                    state = contextState;
                 }
 
                 if (type.IsArray)
                 {
-                    elementState = GetNullabilityInfo(memberInfo, type.GetElementType()!, customAttributes, ref index);
+                    elementState = GetNullabilityInfo(memberInfo, type.GetElementType()!, parser, ref index);
                 }
             }
 
@@ -393,7 +387,7 @@ private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, ILi
 
                 for (int i = 0; i < genericArguments.Length; i++)
                 {
-                    genericArgumentsState[i] = GetNullabilityInfo(memberInfo, genericArguments[i], customAttributes, ref index);
+                    genericArgumentsState[i] = GetNullabilityInfo(memberInfo, genericArguments[i], parser, ref index);
                 }
             }
 
@@ -407,7 +401,7 @@ private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, ILi
             return nullability;
         }
 
-        private static bool ParseNullableState(IList<CustomAttributeData> customAttributes, int index, ref NullabilityState state)
+        private static NullableAttributeStateParser CreateParser(IList<CustomAttributeData> customAttributes)
         {
             foreach (CustomAttributeData attribute in customAttributes)
             {
@@ -415,26 +409,11 @@ private static bool ParseNullableState(IList<CustomAttributeData> customAttribut
                     attribute.AttributeType.Namespace == CompilerServicesNameSpace &&
                     attribute.ConstructorArguments.Count == 1)
                 {
-                    object? o = attribute.ConstructorArguments[0].Value;
-
-                    if (o is byte b)
-                    {
-                        state = TranslateByte(b);
-                        return true;
-                    }
-                    else if (o is ReadOnlyCollection<CustomAttributeTypedArgument> args &&
-                            index < args.Count &&
-                            args[index].Value is byte elementB)
-                        {
-                            state = TranslateByte(elementB);
-                            return true;
-                        }
-
-                    break;
+                    return new(attribute.ConstructorArguments[0].Value);
                 }
             }
 
-            return false;
+            return new(null);
         }
 
         private void TryLoadGenericMetaTypeNullability(MemberInfo memberInfo, NullabilityInfo nullability)
@@ -452,7 +431,7 @@ private void TryLoadGenericMetaTypeNullability(MemberInfo memberInfo, Nullabilit
 
             if (metaType != null)
             {
-                CheckGenericParameters(nullability, metaMember!, metaType);
+                CheckGenericParameters(nullability, metaMember!, metaType, memberInfo.ReflectedType);
             }
         }
 
@@ -477,19 +456,14 @@ private static Type GetPropertyMetaType(PropertyInfo property)
             return property.GetSetMethod(true)!.GetParameters()[0].ParameterType;
         }
 
-        private void CheckGenericParameters(NullabilityInfo nullability, MemberInfo metaMember, Type metaType)
+        private void CheckGenericParameters(NullabilityInfo nullability, MemberInfo metaMember, Type metaType, Type? reflectedType)
         {
             if (metaType.IsGenericParameter)
             {
-                NullabilityState state = nullability.ReadState;
-
-                if (state == NullabilityState.NotNull && !ParseNullableState(metaType.GetCustomAttributesData(), 0, ref state))
+                if (nullability.ReadState == NullabilityState.NotNull)
                 {
-                    state = GetNullableContext(metaType);
+                    TryUpdateGenericParameterNullability(nullability, metaType, reflectedType);
                 }
-
-                nullability.ReadState = state;
-                nullability.WriteState = state;
             }
             else if (metaType.ContainsGenericParameters)
             {
@@ -499,37 +473,136 @@ private void CheckGenericParameters(NullabilityInfo nullability, MemberInfo meta
 
                     for (int i = 0; i < genericArguments.Length; i++)
                     {
-                        if (genericArguments[i].IsGenericParameter)
-                        {
-                            int index = i + 1;
-                            NullabilityInfo n = GetNullabilityInfo(metaMember, genericArguments[i], genericArguments[i].GetCustomAttributesData(), ref index);
-                            nullability.GenericTypeArguments[i].ReadState = n.ReadState;
-                            nullability.GenericTypeArguments[i].WriteState = n.WriteState;
-                        }
-                        else
-                        {
-                            UpdateGenericArrayElements(nullability.GenericTypeArguments[i].ElementType, metaMember, genericArguments[i]);
-                        }
+                        CheckGenericParameters(nullability.GenericTypeArguments[i], metaMember, genericArguments[i], reflectedType);
                     }
                 }
-                else
+                else if (nullability.ElementType is { } elementNullability && metaType.IsArray)
                 {
-                    UpdateGenericArrayElements(nullability.ElementType, metaMember, metaType);
+                    CheckGenericParameters(elementNullability, metaMember, metaType.GetElementType()!, reflectedType);
                 }
             }
         }
 
-        private void UpdateGenericArrayElements(NullabilityInfo? elementState, MemberInfo metaMember, Type metaType)
+        private bool TryUpdateGenericParameterNullability(NullabilityInfo nullability, Type genericParameter, Type? reflectedType)
         {
-            if (metaType.IsArray && elementState != null
-                && metaType.GetElementType()!.IsGenericParameter)
+            Debug.Assert(genericParameter.IsGenericParameter);
+
+            if (reflectedType is not null
+                && !genericParameter.IsGenericMethodParameter
+                && TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, reflectedType, reflectedType))
+            {
+                return true;
+            }
+
+            var state = NullabilityState.Unknown;
+            if (CreateParser(genericParameter.GetCustomAttributesData()).ParseNullableState(0, ref state))
+            {
+                nullability.ReadState = state;
+                nullability.WriteState = state;
+                return true;
+            }
+
+            if (GetNullableContext(genericParameter) is { } contextState)
             {
-                Type elementType = metaType.GetElementType()!;
-                int index = 0;
-                NullabilityInfo n = GetNullabilityInfo(metaMember, elementType, elementType.GetCustomAttributesData(), ref index);
-                elementState.ReadState = n.ReadState;
-                elementState.WriteState = n.WriteState;
+                nullability.ReadState = contextState;
+                nullability.WriteState = contextState;
+                return true;
             }
+
+            return false;
+        }
+
+        private bool TryUpdateGenericTypeParameterNullabilityFromReflectedType(NullabilityInfo nullability, Type genericParameter, Type context, Type reflectedType)
+        {
+            Debug.Assert(genericParameter.IsGenericParameter && !genericParameter.IsGenericMethodParameter);
+
+            Type contextTypeDefinition = context.IsGenericType && !context.IsGenericTypeDefinition ? context.GetGenericTypeDefinition() : context;
+            if (genericParameter.DeclaringType == contextTypeDefinition)
+            {
+                return false;
+            }
+
+            Type? baseType = contextTypeDefinition.BaseType;
+            if (baseType is null)
+            {
+                return false;
+            }
+
+            if (!baseType.IsGenericType
+                || (baseType.IsGenericTypeDefinition ? baseType : baseType.GetGenericTypeDefinition()) != genericParameter.DeclaringType)
+            {
+                return TryUpdateGenericTypeParameterNullabilityFromReflectedType(nullability, genericParameter, baseType, reflectedType);
+            }
+
+            Type[] genericArguments = baseType.GetGenericArguments();
+            Type genericArgument = genericArguments[genericParameter.GenericParameterPosition];
+            if (genericArgument.IsGenericParameter)
+            {
+                return TryUpdateGenericParameterNullability(nullability, genericArgument, reflectedType);
+            }
+
+            NullableAttributeStateParser parser = CreateParser(contextTypeDefinition.GetCustomAttributesData());
+            int nullabilityStateIndex = 1; // start at 1 since index 0 is the type itself
+            for (int i = 0; i < genericParameter.GenericParameterPosition; i++)
+            {
+                nullabilityStateIndex += CountNullabilityStates(genericArguments[i]);
+            }
+            return TryPopulateNullabilityInfo(nullability, parser, ref nullabilityStateIndex);
+
+            static int CountNullabilityStates(Type type)
+            {
+                Type underlyingType = Nullable.GetUnderlyingType(type) ?? type;
+                if (underlyingType.IsGenericType)
+                {
+                    int count = 1;
+                    foreach (Type genericArgument in underlyingType.GetGenericArguments())
+                    {
+                        count += CountNullabilityStates(genericArgument);
+                    }
+                    return count;
+                }
+                if (underlyingType.IsArray)
+                {
+                    return 1 + CountNullabilityStates(underlyingType.GetElementType()!);
+                }
+
+                return type.IsValueType ? 0 : 1;
+            }
+        }
+
+        private bool TryPopulateNullabilityInfo(NullabilityInfo nullability, NullableAttributeStateParser parser, ref int index)
+        {
+            bool isValueType = nullability.Type.IsValueType;
+            if (!isValueType)
+            {
+                var state = NullabilityState.Unknown;
+                if (!parser.ParseNullableState(index, ref state))
+                {
+                    return false;
+                }
+
+                nullability.ReadState = state;
+                nullability.WriteState = state;
+            }
+
+            if (!isValueType || (Nullable.GetUnderlyingType(nullability.Type) ?? nullability.Type).IsGenericType)
+            {
+                index++;
+            }
+
+            if (nullability.GenericTypeArguments.Length > 0)
+            {
+                foreach (NullabilityInfo genericTypeArgumentNullability in nullability.GenericTypeArguments)
+                {
+                    TryPopulateNullabilityInfo(genericTypeArgumentNullability, parser, ref index);
+                }
+            }
+            else if (nullability.ElementType is { } elementTypeNullability)
+            {
+                TryPopulateNullabilityInfo(elementTypeNullability, parser, ref index);
+            }
+
+            return true;
         }
 
         private static NullabilityState TranslateByte(object? value)
@@ -544,5 +617,35 @@ private static NullabilityState TranslateByte(byte b) =>
                 2 => NullabilityState.Nullable,
                 _ => NullabilityState.Unknown
             };
+
+        private readonly struct NullableAttributeStateParser
+        {
+            private static readonly object UnknownByte = (byte)0;
+
+            private readonly object? _nullableAttributeArgument;
+
+            public NullableAttributeStateParser(object? nullableAttributeArgument)
+            {
+                this._nullableAttributeArgument = nullableAttributeArgument;
+            }
+
+            public static NullableAttributeStateParser Unknown => new(UnknownByte);
+
+            public bool ParseNullableState(int index, ref NullabilityState state)
+            {
+                switch (this._nullableAttributeArgument)
+                {
+                    case byte b:
+                        state = TranslateByte(b);
+                        return true;
+                    case ReadOnlyCollection<CustomAttributeTypedArgument> args
+                        when index < args.Count && args[index].Value is byte elementB:
+                        state = TranslateByte(elementB);
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Runtime/tests/System/Reflection/NullabilityInfoContextTests.cs b/src/libraries/System.Runtime/tests/System/Reflection/NullabilityInfoContextTests.cs
index ce939d45263024..7dd057d8cca0ad 100644
--- a/src/libraries/System.Runtime/tests/System/Reflection/NullabilityInfoContextTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Reflection/NullabilityInfoContextTests.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO.Enumeration;
+using System.Runtime.Serialization;
 using System.Text.RegularExpressions;
 using Microsoft.DotNet.RemoteExecutor;
 using Xunit;
@@ -30,10 +31,10 @@ public static IEnumerable<object[]> FieldTestData()
             yield return new object[] { "FieldDisallowNull", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
             yield return new object[] { "FieldAllowNull", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
             yield return new object[] { "FieldDisallowNull2", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
-            yield return new object[] { "FieldAllowNull2", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
+            yield return new object[] { "FieldAllowNull2", NullabilityState.NotNull, NullabilityState.NotNull, typeof(string) };
             yield return new object[] { "FieldNotNull", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
             yield return new object[] { "FieldMaybeNull", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
-            yield return new object[] { "FieldMaybeNull2", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
+            yield return new object[] { "FieldMaybeNull2", NullabilityState.NotNull, NullabilityState.NotNull, typeof(string) };
             yield return new object[] { "FieldNotNull2", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
         }
 
@@ -86,11 +87,12 @@ public static IEnumerable<object[]> PropertyTestData()
             yield return new object[] { "PropertyDisallowNull", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
             yield return new object[] { "PropertyAllowNull", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
             yield return new object[] { "PropertyDisallowNull2", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
-            yield return new object[] { "PropertyAllowNull2", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
+            yield return new object[] { "PropertyAllowNull2", NullabilityState.NotNull, NullabilityState.NotNull, typeof(string) };
             yield return new object[] { "PropertyNotNull", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
             yield return new object[] { "PropertyMaybeNull", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
-            yield return new object[] { "PropertyMaybeNull2", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
+            yield return new object[] { "PropertyMaybeNull2", NullabilityState.NotNull, NullabilityState.NotNull, typeof(string) };
             yield return new object[] { "PropertyNotNull2", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
+            yield return new object[] { "Item", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
         }
 
         [Theory]
@@ -433,7 +435,7 @@ public void GenericFieldNullableValueTypeTest(string fieldName, NullabilityState
             Assert.Equal(type, nullability.Type);
         }
 
-        public static IEnumerable<object[]> GenericNotnullConstraintFieldsTestData()
+        public static IEnumerable<object[]> GenericNotNullConstraintFieldsTestData()
         {
             yield return new object[] { "FieldNullable", NullabilityState.Nullable, NullabilityState.Nullable, typeof(string) };
             yield return new object[] { "FieldUnknown", NullabilityState.Unknown, NullabilityState.Unknown, typeof(string) };
@@ -441,7 +443,7 @@ public static IEnumerable<object[]> GenericNotnullConstraintFieldsTestData()
         }
 
         [Theory]
-        [MemberData(nameof(GenericNotnullConstraintFieldsTestData))]
+        [MemberData(nameof(GenericNotNullConstraintFieldsTestData))]
         public void GenericNotNullConstraintFieldsTest(string fieldName, NullabilityState readState, NullabilityState writeState, Type type)
         {
             FieldInfo field = typeof(GenericTestConstrainedNotNull<string>).GetField(fieldName, flags)!;
@@ -570,7 +572,7 @@ public void GenericListAndDictionaryFieldTest()
 
         public static IEnumerable<object[]> MethodReturnParameterTestData()
         {
-            yield return new object[] { "MethodReturnsUnknown", NullabilityState.Unknown, NullabilityState.Unknown};
+            yield return new object[] { "MethodReturnsUnknown", NullabilityState.Unknown, NullabilityState.Unknown };
             yield return new object[] { "MethodReturnsNullNon", NullabilityState.Nullable, NullabilityState.NotNull };
             yield return new object[] { "MethodReturnsNullNull", NullabilityState.Nullable, NullabilityState.Nullable };
             yield return new object[] { "MethodReturnsNonNull", NullabilityState.NotNull, NullabilityState.Nullable };
@@ -671,7 +673,7 @@ public void MethodParametersTest(string methodName, NullabilityState stringState
 
         public static IEnumerable<object[]> MethodGenericParametersTestData()
         {
-            yield return new object[] { "MethodParametersUnknown", NullabilityState.Unknown, NullabilityState.Unknown, NullabilityState.Unknown, NullabilityState.Unknown};
+            yield return new object[] { "MethodParametersUnknown", NullabilityState.Unknown, NullabilityState.Unknown, NullabilityState.Unknown, NullabilityState.Unknown };
             yield return new object[] { "MethodArgsNullGenericNullDictValueGeneric", NullabilityState.Nullable, NullabilityState.NotNull, NullabilityState.Nullable, NullabilityState.Nullable };
             yield return new object[] { "MethodArgsGenericDictValueNullGeneric", NullabilityState.Nullable, NullabilityState.NotNull, NullabilityState.Nullable, NullabilityState.NotNull };
         }
@@ -710,7 +712,7 @@ public void NullablePublicOnlyStringTypeTest(string methodName, NullabilityState
             Assert.Equal(param1State, param1.ReadState);
             Assert.Equal(param2State, param2.ReadState);
             Assert.Equal(param3State, param3.ReadState);
-            if (param2.ElementType  != null)
+            if (param2.ElementType != null)
             {
                 Assert.Equal(NullabilityState.Nullable, param2.ElementType.ReadState);
             }
@@ -739,7 +741,7 @@ public void NullablePublicOnlyOtherTypesTest()
             PropertyInfo publicGetPrivateSetNullableProperty = typeof(FileSystemEntry).GetProperty("Directory", flags)!;
             info = nullabilityContext.Create(publicGetPrivateSetNullableProperty);
             Assert.Equal(NullabilityState.NotNull, info.ReadState);
-            Assert.Equal(NullabilityState.Unknown, info.WriteState);
+            Assert.Equal(NullabilityState.NotNull, info.WriteState);
 
             MethodInfo protectedNullableReturnMethod = type.GetMethod("GetPropertyImpl", flags)!;
             info = nullabilityContext.Create(protectedNullableReturnMethod.ReturnParameter);
@@ -748,8 +750,8 @@ public void NullablePublicOnlyOtherTypesTest()
 
             MethodInfo privateValueTypeReturnMethod = type.GetMethod("BinarySearch", flags)!;
             info = nullabilityContext.Create(privateValueTypeReturnMethod.ReturnParameter);
-            Assert.Equal(NullabilityState.Unknown, info.ReadState);
-            Assert.Equal(NullabilityState.Unknown, info.WriteState);
+            Assert.Equal(NullabilityState.NotNull, info.ReadState);
+            Assert.Equal(NullabilityState.NotNull, info.WriteState);
 
             Type regexType = typeof(Regex);
             FieldInfo protectedInternalNullableField = regexType.GetField("pattern", flags)!;
@@ -761,13 +763,18 @@ public void NullablePublicOnlyOtherTypesTest()
             info = nullabilityContext.Create(privateNullableField);
             Assert.Equal(NullabilityState.Unknown, info.ReadState);
             Assert.Equal(NullabilityState.Unknown, info.WriteState);
+
+            ConstructorInfo privateConstructor = typeof(IndexOutOfRangeException)
+                .GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, new[] { typeof(SerializationInfo), typeof(StreamingContext) })!;
+            info = nullabilityContext.Create(privateConstructor.GetParameters()[0]);
+            Assert.Equal(NullabilityState.Unknown, info.WriteState);
         }
 
         public static IEnumerable<object[]> DifferentContextTestData()
         {
             yield return new object[] { "PropertyDisabled", NullabilityState.Unknown, NullabilityState.Unknown, typeof(string) };
-            yield return new object[] { "PropertyDisabledAllowNull", NullabilityState.Unknown, NullabilityState.Unknown, typeof(string) };
-            yield return new object[] { "PropertyDisabledMaybeNull", NullabilityState.Unknown, NullabilityState.Unknown, typeof(string) };
+            yield return new object[] { "PropertyDisabledAllowNull", NullabilityState.Unknown, NullabilityState.Nullable, typeof(string) };
+            yield return new object[] { "PropertyDisabledMaybeNull", NullabilityState.Nullable, NullabilityState.Unknown, typeof(string) };
             yield return new object[] { "PropertyEnabledAllowNull", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
             yield return new object[] { "PropertyEnabledNotNull", NullabilityState.NotNull, NullabilityState.Nullable, typeof(string) };
             yield return new object[] { "PropertyEnabledMaybeNull", NullabilityState.Nullable, NullabilityState.NotNull, typeof(string) };
@@ -984,6 +991,105 @@ public void TestValueTupleGenericTypeParameters(string fieldName, NullabilitySta
             Assert.Equal(param1, tupleInfo.GenericTypeArguments[0].ReadState);
             Assert.Equal(param2, tupleInfo.GenericTypeArguments[1].ReadState);
         }
+
+        public static IEnumerable<object?[]> GenericInheritanceTestData()
+        {
+            yield return new object?[] { typeof(ListOfUnconstrained<string?>), NullabilityState.Nullable, null };
+            yield return new object?[] { typeof(ListUnconstrainedOfNullable<string>), NullabilityState.Nullable, null };
+            yield return new object?[] { typeof(ListUnconstrainedOfNullableOfObject<>), NullabilityState.NotNull, null };
+            yield return new object?[] { typeof(ListOfArrayOfNullableString), NullabilityState.NotNull, NullabilityState.Nullable };
+            yield return new object?[] { typeof(ListOfNotNull<ListOfNotNull<object>>), NullabilityState.NotNull, NullabilityState.NotNull };
+            yield return new object?[] { typeof(ListOfListOfObject<string?>), NullabilityState.NotNull, NullabilityState.NotNull };
+            yield return new object?[] { typeof(ListMultiGenericOfNotNull<object?, string, string?>), NullabilityState.NotNull, null };
+        }
+
+        [Theory]
+        [MemberData(nameof(GenericInheritanceTestData))]
+        [SkipOnMono("Nullability attributes trimmed on Mono")]
+        public void TestGenericInheritance(Type listType, NullabilityState parameterState, NullabilityState? subState)
+        {
+            var addParameterInfo = nullabilityContext.Create(listType.GetMethod("Add")!.GetParameters()[0]);
+            Validate(addParameterInfo);
+
+            var copyToParameterInfo = nullabilityContext.Create(
+                listType.GetMethod("CopyTo", new[] { addParameterInfo.Type.MakeArrayType() })!
+                    .GetParameters()[0]);
+            Assert.Equal(NullabilityState.NotNull, copyToParameterInfo.ReadState);
+            Assert.Equal(NullabilityState.NotNull, copyToParameterInfo.WriteState);
+            Assert.NotNull(copyToParameterInfo.ElementType);
+            Validate(copyToParameterInfo.ElementType!);
+
+            void Validate(NullabilityInfo info)
+            {
+                Assert.Equal(parameterState, info.ReadState);
+                Assert.Equal(parameterState, info.WriteState);
+                if (subState != null)
+                {
+                    NullabilityInfo subInfo = info.ElementType ?? info.GenericTypeArguments[0];
+                    Assert.Equal(subState, subInfo.ReadState);
+                    Assert.Equal(subState, subInfo.WriteState);
+                    Assert.True(info.GenericTypeArguments.Length <= 1);
+                }
+                else
+                {
+                    Assert.Null(info.ElementType);
+                    Assert.Empty(info.GenericTypeArguments);
+                }
+            }
+        }
+
+        [Fact]
+        [SkipOnMono("Nullability attributes trimmed on Mono")]
+        public void TestDeeplyNestedGenericInheritance()
+        {
+            var copyToMethodInfo = nullabilityContext.Create(
+                typeof(ListOfTupleOfDictionaryOfStringNullableBoolIntNullableObject).GetMethod("CopyTo", new[] { typeof((Dictionary<string, bool?>, int, object?)[]) })!
+                    .GetParameters()[0]);
+
+            Validate(copyToMethodInfo, typeof((Dictionary<string, bool?>, int, object?)[]), NullabilityState.NotNull);
+            Assert.NotNull(copyToMethodInfo.ElementType);
+
+            var tupleInfo = copyToMethodInfo.ElementType!;
+            Validate(tupleInfo, typeof((Dictionary<string, bool?>, int, object?)), NullabilityState.NotNull);
+
+            var dictionaryInfo = tupleInfo.GenericTypeArguments[0];
+            Validate(dictionaryInfo, typeof(Dictionary<string, bool?>), NullabilityState.NotNull);
+
+            var stringInfo = dictionaryInfo.GenericTypeArguments[0];
+            Validate(stringInfo, typeof(string), NullabilityState.NotNull);
+
+            var nullableBoolInfo = dictionaryInfo.GenericTypeArguments[1];
+            Validate(nullableBoolInfo, typeof(bool?), NullabilityState.Nullable);
+
+            var intInfo = tupleInfo.GenericTypeArguments[1];
+            Validate(intInfo, typeof(int), NullabilityState.NotNull);
+
+            var objectInfo = tupleInfo.GenericTypeArguments[2];
+            Validate(objectInfo, typeof(object), NullabilityState.Nullable);
+
+            void Validate(NullabilityInfo info, Type type, NullabilityState state)
+            {
+                Assert.Equal(type, info.Type);
+                Assert.Equal(state, info.ReadState);
+                Assert.Equal(state, info.WriteState);
+                Assert.Equal(type.IsGenericType && type.GetGenericTypeDefinition() != typeof(Nullable<>) ? type.GetGenericArguments().Length : 0, info.GenericTypeArguments.Length);
+                Assert.Equal(type.IsArray, info.ElementType is not null);
+            }
+        }
+
+        [Fact]
+        [SkipOnMono("Nullability attributes trimmed on Mono")]
+        public void TestNestedGenericInheritanceWithMultipleParameters()
+        {
+            var item3Info = nullabilityContext.Create(typeof(DerivesFromTupleOfNestedGenerics).GetProperty("Item3")!);
+
+            Assert.Equal(typeof(IDisposable[]), item3Info.Type);
+            Assert.Equal(NullabilityState.Nullable, item3Info.ReadState);
+            Assert.Equal(NullabilityState.Unknown, item3Info.WriteState); // read-only property
+
+            Assert.Equal(NullabilityState.NotNull, item3Info.ElementType!.ReadState);
+            Assert.Equal(NullabilityState.NotNull, item3Info.ElementType.WriteState);
+        }
     }
 
 #pragma warning disable CS0649, CS0067, CS0414
@@ -1023,7 +1129,7 @@ public class TypeWithNoContext
         [AllowNull] public string PropertyEnabledAllowNull { get; set; }
         [NotNull] public string? PropertyEnabledNotNull { get; set; } = null!;
         [DisallowNull] public string? PropertyEnabledDisallowNull { get; set; } = null!;
-        [MaybeNull] public string PropertyEnabledMaybeNull { get; set; } 
+        [MaybeNull] public string PropertyEnabledMaybeNull { get; set; }
         public string? PropertyEnabledNullable { get; set; }
         public string PropertyEnabledNonNullable { get; set; } = null!;
 #nullable disable
@@ -1059,14 +1165,15 @@ public void MethodParametersUnknown(string s, IDictionary<Type, string[]> dict)
         [AllowNull] public string PropertyAllowNull { get; set; }
         [NotNull] public string? PropertyNotNull { get; set; }
         [MaybeNull] public string PropertyMaybeNull { get; set; }
-        // only AllowNull matter
+        // only DisallowNull matters
         [AllowNull, DisallowNull] public string PropertyAllowNull2 { get; set; }
-        // only DisallowNull matter
+        // only AllowNull matters
         [AllowNull, DisallowNull] public string? PropertyDisallowNull2 { get; set; }
-        // only NotNull matter
+        // only NotNull matters
         [NotNull, MaybeNull] public string? PropertyNotNull2 { get; set; }
-        // only MaybeNull matter
+        // only NotNull matters
         [NotNull, MaybeNull] public string PropertyMaybeNull2 { get; set; }
+        [DisallowNull] public string? this[int i] { get => null; set { } }
         private protected string?[]?[]? PropertyJaggedArrayNullNullNull { get; set; }
         public static string?[]?[] PropertyJaggedArrayNullNullNon { get; set; } = null!;
         public string?[][]? PropertyJaggedArrayNullNonNull { get; set; }
@@ -1174,7 +1281,7 @@ public void MethodParametersUnknown(T s, IDictionary<Type, T> dict) { }
         [DisallowNull] public T? FieldDisallowNull;
         [AllowNull] protected T FieldAllowNull;
         [NotNull] public T? FieldNotNull = default;
-        [MaybeNull] protected internal  T FieldMaybeNull = default!;
+        [MaybeNull] protected internal T FieldMaybeNull = default!;
         public List<T> FieldListOfT = default!;
         public Dictionary<string, T> FieldDictionaryStringToT = default!;
 
@@ -1213,4 +1320,33 @@ internal class GenericTestConstrainedStruct<T> where T : struct
         public T PropertyNullableEnabled { get; set; }
         public T? PropertyNullable { get; set; }
     }
+
+    public class ListOfUnconstrained<T> : List<T> { }
+
+    public class ListUnconstrainedOfNullable<T> : ListOfUnconstrained<T> where T : class? { }
+
+    public class ListUnconstrainedOfNullableOfObject<T> : ListUnconstrainedOfNullable<object> { }
+
+    public class ListOfArrayOfNullableString : List<string?[]> { }
+
+    public class ListOfNotNull<T> : List<T> where T : notnull { }
+
+    public class ListOfListOfObject<T> : List<List<object>> { }
+
+    public class ListMultiGenericOfNotNull<T, U, V> : List<U>
+        where T : class?
+        where U : class
+        where V : class?
+    {
+    }
+
+    public class ListOfTupleOfDictionaryOfStringNullableBoolIntNullableObject : List<(Dictionary<string, bool?>, int, object?)> { }
+
+    public class DerivesFromTupleOfNestedGenerics : Tuple<List<string[]>, Dictionary<object[], List<object>>, IDisposable[]?>
+    {
+        public DerivesFromTupleOfNestedGenerics(List<string[]> item1, Dictionary<object[], List<object>> item2, IDisposable[]? item3)
+            : base(item1, item2, item3)
+        {
+        }
+    }
 }

From 7fcd1f6e45d937b9835c6cf2b0a2f76e0c180e87 Mon Sep 17 00:00:00 2001
From: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date: Thu, 27 Jan 2022 04:21:12 +0300
Subject: [PATCH 099/161] Reverse ASG(CLS_VAR, ...) (#63957)

This helps with register allocation. Consider:
```
***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N003 ( 18, 10) [000003] -ACXG-------              *  ASG       ref    $c0
N001 (  3,  4) [000002] ----G--N----              +--*  CLS_VAR   ref    Hnd=0x8fec230 Fseq[hackishFieldName]
N002 ( 14,  5) [000000] --CXG-------              \--*  CALL      ref    CscBench.GetMscorlibPathCore $c0
```
The rationalizer will rewrite it to what is effectively:
```
***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N004 ( 18, 12) [000003] -ACXG---R---              *  ASG       ref
N003 (  3,  6) [000002] n---G--N----              +--*  IND       ref
N002 (  1,  4) [000006] H-----------              |  \--*  CLS_VAR_ADDR byref  Hnd=0x8fec230
N001 ( 14,  5) [000000] --CXG-------              \--*  CALL      ref    CscBench.GetMscorlibPathCore
```
And the final LIR will look like:
```
               [000006] ------------                 IL_OFFSET void   INLRT @ 0x000[E-]
N001 (  3,  4) [000002] ----G--N----         t2 =    CLS_VAR_ADDR byref  Hnd=0x8fec230
N002 ( 14,  5) [000000] --CXG-------         t0 =    CALL      ref    CscBench.GetMscorlibPathCore $c0
                                                  /--*  t2     byref
                                                  +--*  t0     ref
N003 ( 18, 10) [000003] -A-XG-------              *  STOREIND  ref
               [000007] ------------                 IL_OFFSET void   INLRT @ 0x00A[E-]
N001 (  0,  0) [000004] ------------                 RETURN    void   $180
```
Since this store must use a barrier, `CLS_VAR_ADDR` won't be contained and will have to be evaludated
separately. Because its value is live across a call, it'll get spilled and reloaded. Reversing the ASG
fixes the problem:
```
------------ BB01 [000..00B) (return), preds={} succs={}
               [000006] ------------                 IL_OFFSET void   INLRT @ 0x000[E-]
N001 ( 14,  5) [000000] --CXG-------         t0 =    CALL      ref    CscBench.GetMscorlibPathCore $c0
N002 (  3,  4) [000002] ----G--N----         t2 =    CLS_VAR_ADDR byref  Hnd=0x8fec230
                                                  /--*  t2     byref
                                                  +--*  t0     ref
N003 ( 18, 10) [000003] -A-XG-------              *  STOREIND  ref
               [000007] ------------                 IL_OFFSET void   INLRT @ 0x00A[E-]
N001 (  0,  0) [000004] ------------                 RETURN    void   $180
```
---
 src/coreclr/jit/gentree.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index 68a7b49d74dbb4..23c9d1a0f149b6 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -4176,6 +4176,7 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
 
                 case GT_LCL_VAR:
                 case GT_LCL_FLD:
+                case GT_CLS_VAR:
 
                     // We evaluate op2 before op1
                     bReverseInAssignment = true;

From 5f72148e033b887ede8436fcdefdbec6cda83190 Mon Sep 17 00:00:00 2001
From: Andrew Au <andrewau@microsoft.com>
Date: Wed, 26 Jan 2022 17:24:15 -0800
Subject: [PATCH 100/161] Fixes a few issues for dprintf on OSX (#64076)

---
 src/coreclr/gc/gc.cpp              |  6 +++---
 src/coreclr/utilcode/stresslog.cpp | 15 ++++++++++++++-
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp
index 4842346ad26af4..3927e97c723b35 100644
--- a/src/coreclr/gc/gc.cpp
+++ b/src/coreclr/gc/gc.cpp
@@ -27459,7 +27459,7 @@ void gc_heap::plan_phase (int condemned_gen_number)
         _sort (&mark_list[0], mark_list_index - 1, 0);
 #endif //USE_VXSORT
 
-        dprintf (3, ("using mark list at GC #%d", settings.gc_index));
+        dprintf (3, ("using mark list at GC #%Id", (size_t)settings.gc_index));
         //verify_qsort_array (&mark_list[0], mark_list_index-1);
 #endif //!MULTIPLE_HEAPS
         use_mark_list = TRUE;
@@ -36666,7 +36666,7 @@ void gc_heap::mark_through_cards_for_segments (card_fn fn, BOOL relocating CARD_
             hpt->heap_number, heap_number, n_eph, n_gen, n_card_set, total_cards_cleared,
             (n_eph ? (int)(((float)n_gen / (float)n_eph) * 100) : 0)));
         dprintf (3, ("h%d marking h%d Msoh: total cross %Id, useful: %Id, running ratio: %d",
-            hpt->heap_number, heap_number, n_eph_soh, n_gen_soh,
+            hpt->heap_number, heap_number, (size_t)n_eph_soh, (size_t)n_gen_soh,
             (n_eph_soh ? (int)(((float)n_gen_soh / (float)n_eph_soh) * 100) : 0)));
 #else
         generation_skip_ratio = ((n_eph > MIN_SOH_CROSS_GEN_REFS) ? (int)(((float)n_gen / (float)n_eph) * 100) : 100);
@@ -41414,7 +41414,7 @@ void gc_heap::mark_through_cards_for_uoh_objects (card_fn fn,
             hpt->heap_number, heap_number, n_eph, n_gen, n_card_set, total_cards_cleared,
             (n_eph ? (int)(((float)n_gen / (float)n_eph) * 100) : 0)));
         dprintf (3, ("h%d marking h%d Mloh: total cross %Id, useful: %Id, running ratio: %d",
-            hpt->heap_number, heap_number, n_eph_loh, n_gen_loh,
+            hpt->heap_number, heap_number, (size_t)n_eph_loh, (size_t)n_gen_loh,
             (n_eph_loh ? (int)(((float)n_gen_loh / (float)n_eph_loh) * 100) : 0)));
 #else
         generation_skip_ratio = min (((n_eph > MIN_LOH_CROSS_GEN_REFS) ?
diff --git a/src/coreclr/utilcode/stresslog.cpp b/src/coreclr/utilcode/stresslog.cpp
index a9e36516b6dcd2..5d13b2ec7695ca 100644
--- a/src/coreclr/utilcode/stresslog.cpp
+++ b/src/coreclr/utilcode/stresslog.cpp
@@ -345,6 +345,12 @@ void StressLog::AddModule(uint8_t* moduleBase)
     }
 #endif //MEMORY_MAPPED_STRESSLOG
     theLog.modules[moduleIndex].size = PAL_CopyModuleData(moduleBase, destination, destination_end);
+#ifdef MEMORY_MAPPED_STRESSLOG
+    if (hdr != nullptr)
+    {
+        hdr->modules[moduleIndex].size = theLog.modules[moduleIndex].size;
+    }
+#endif //MEMORY_MAPPED_STRESSLOG
 #endif //HOST_WINDOWS
 }
 
@@ -884,7 +890,6 @@ void StressLog::LogMsg(unsigned level, unsigned facility, const StressLogMsg &ms
 
     if (InlinedStressLogOn(facility, level))
     {
-#ifdef HOST_WINDOWS // On Linux, this cast: (va_list)msg.m_args gives a compile error
        ThreadStressLog* msgs = t_pCurrentThreadLog;
 
         if (msgs == 0)
@@ -894,7 +899,15 @@ void StressLog::LogMsg(unsigned level, unsigned facility, const StressLogMsg &ms
             if (msgs == 0)
                 return;
         }
+#ifdef HOST_WINDOWS 
+        // On Linux, this cast: (va_list)msg.m_args gives a compile error
         msgs->LogMsg(facility, msg.m_cArgs, msg.m_format, (va_list)msg.m_args);
+#else
+        msgs->LogMsg(facility, msg.m_cArgs, msg.m_format, 
+        msg.m_args[0], msg.m_args[1], msg.m_args[2], msg.m_args[3], 
+        msg.m_args[4], msg.m_args[5], msg.m_args[6], msg.m_args[7], 
+        msg.m_args[8], msg.m_args[9], msg.m_args[10], msg.m_args[11], 
+        msg.m_args[12], msg.m_args[13], msg.m_args[14], msg.m_args[15]);
 #endif //HOST_WINDOWS
     }
 

From 5a9bcde1d52b8b5a6c7b70883704bcb349c54c12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aleksey=20Kliger=20=28=CE=BBgeek=29?= <alklig@microsoft.com>
Date: Wed, 26 Jan 2022 21:00:00 -0500
Subject: [PATCH 101/161] [Codespaces] Make it possible to run wasm samples in
 the browser (#64277)

With these changes, running the following in the Codespace will open the local browser to a page served from the codespace hosting the WASM sample:

```console
cd src/mono/sample/wasm/browser
make
make run-browser
```


* Set EMSDK_PATH in .devcontainer.json

   We provision Emscripten as part of the devcontainer prebuild.

   Set EMSDK_PATH to allow rebuilding the wasm runtime to work without any additional ceremony

* Install dotnet-serve into .dotnet-tools-global

* [wasm] Don't try to open browser if running in Codespaces

* .devcontainer: add global tools dir to PATH

* .devcontainer: forward port 8000

   This enables running the mono wasm samples in the local browser:

* [wasm] samples: also check for dotnet-serve on the path

   On Codespaces we install dotnet-serve on the PATH but not where `dotnet tool list` can see it

* remove onAutoForward: notify - it's the default

* Adjust the path of v8 depends if running in a dev container

* Check if we're running in any Docker container, not just Codespaces

Co-authored-by: Fan Yang <52458914+fanyang-mono@users.noreply.github.com>
---
 .devcontainer/devcontainer.json          | 19 +++++++++++++++----
 .devcontainer/scripts/onCreateCommand.sh |  3 +++
 .gitignore                               |  1 +
 src/mono/sample/wasm/wasm.mk             | 15 ++++++++++++---
 4 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 41e9c94c00deee..d7b5a8b0efb57a 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -4,7 +4,7 @@
 	"name": "C# (.NET)",
 	"build": {
 		"dockerfile": "Dockerfile",
-		"args": { 
+		"args": {
 			// Update 'VARIANT' to pick a .NET Core version: 2.1, 3.1, 5.0
 			"VARIANT": "5.0",
 		}
@@ -32,11 +32,22 @@
 
 	// Add the locally installed dotnet to the path to ensure that it is activated
 	// This allows developers to just use 'dotnet build' on the command-line, and the local dotnet version will be used.
+	// Add the global tools dir to the PATH so that globally installed tools will work
 	"remoteEnv": {
-		"PATH": "${containerWorkspaceFolder}/.dotnet:${containerEnv:PATH}",
-		"DOTNET_MULTILEVEL_LOOKUP": "0"
+		"PATH": "${containerWorkspaceFolder}/.dotnet:${containerWorkspaceFolder}/.dotnet-tools-global:${containerEnv:PATH}",
+		"DOTNET_MULTILEVEL_LOOKUP": "0",
+		// Path to provisioned Emscripten SDK, for rebuilding the wasm runtime
+		"EMSDK_PATH": "${containerWorkspaceFolder}/src/mono/wasm/emsdk",
 	},
 
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-	"remoteUser": "vscode"
+	"remoteUser": "vscode",
+
+	// Forward mono samples port
+	"forwardPorts": [8000],
+	"portsAttributes": {
+		"8000": {
+			"label": "mono wasm samples (8000)",
+		}
+	}
 }
diff --git a/.devcontainer/scripts/onCreateCommand.sh b/.devcontainer/scripts/onCreateCommand.sh
index 9a7e6718ba32d4..48850f5f00b719 100755
--- a/.devcontainer/scripts/onCreateCommand.sh
+++ b/.devcontainer/scripts/onCreateCommand.sh
@@ -12,5 +12,8 @@ make -C src/mono/wasm provision-wasm
 export EMSDK_PATH=$PWD/src/mono/wasm/emsdk
 ./build.sh mono+libs -os Browser -c release
 
+# install dotnet-serve for running wasm samples
+./dotnet.sh tool install dotnet-serve --tool-path ./.dotnet-tools-global
+
 # save the commit hash of the currently built assemblies, so developers know which version was built
 git rev-parse HEAD > ./artifacts/prebuild.sha
diff --git a/.gitignore b/.gitignore
index 6627d2c2d0a75b..a4848da2e9ca5c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@ syntax: glob
 #       instead of directories), git will still ignore them.
 .dotnet
 .dotnet-mono
+.dotnet-tools-global
 .packages
 .tools
 
diff --git a/src/mono/sample/wasm/wasm.mk b/src/mono/sample/wasm/wasm.mk
index 89759c3c7745ca..ea466c3f225b94 100644
--- a/src/mono/sample/wasm/wasm.mk
+++ b/src/mono/sample/wasm/wasm.mk
@@ -10,6 +10,15 @@ CONFIG?=Release
 
 WASM_DEFAULT_BUILD_ARGS?=/p:TargetArchitecture=wasm /p:TargetOS=Browser /p:Configuration=$(CONFIG)
 
+# if we're in a container, don't try to open the browser
+ifneq ("$(wildcard /.dockerenv)", "")
+  OPEN_BROWSER=
+  V8_PATH=v8
+else
+  OPEN_BROWSER=-o
+  V8_PATH=~/.jsvu/v8
+endif
+
 all: publish
 
 build:
@@ -22,15 +31,15 @@ clean:
 	rm -rf bin $(TOP)/artifacts/obj/mono/$(PROJECT_NAME:%.csproj=%)
 
 run-browser:
-	if ! $(DOTNET) tool list --global | grep dotnet-serve; then \
+	if ! $(DOTNET) tool list --global | grep dotnet-serve && ! which dotnet-serve ; then \
 		echo "The tool dotnet-serve could not be found. Install with: $(DOTNET) tool install --global dotnet-serve"; \
 		exit 1; \
 	else  \
-		$(DOTNET) serve -d:bin/$(CONFIG)/AppBundle -o -p:8000; \
+		$(DOTNET) serve -d:bin/$(CONFIG)/AppBundle $(OPEN_BROWSER) -p:8000; \
 	fi
 
 run-console:
-	cd bin/$(CONFIG)/AppBundle && ~/.jsvu/v8 --stack-trace-limit=1000 --single-threaded --expose_wasm $(MAIN_JS) -- $(DOTNET_MONO_LOG_LEVEL) --run $(CONSOLE_DLL) $(ARGS)
+	cd bin/$(CONFIG)/AppBundle && $(V8_PATH) --stack-trace-limit=1000 --single-threaded --expose_wasm $(MAIN_JS) -- $(DOTNET_MONO_LOG_LEVEL) --run $(CONSOLE_DLL) $(ARGS)
 
 run-console-node:
 	cd bin/$(CONFIG)/AppBundle && node --stack-trace-limit=1000 --single-threaded --expose_wasm $(MAIN_JS) -- $(DOTNET_MONO_LOG_LEVEL) --run $(CONSOLE_DLL) $(ARGS)

From dde66c4cd2587a480d2ee07ba74b0ee9aca8805c Mon Sep 17 00:00:00 2001
From: Elinor Fung <elfung@microsoft.com>
Date: Wed, 26 Jan 2022 20:01:24 -0800
Subject: [PATCH 102/161] Remove workarounds for RemoteExecutor
 (dotnet/arcade#5865) (#64360)

---
 .../tests/UnitTests/ConsoleLifetimeExitTests.cs        |  9 ---------
 .../InteropServices/ObjectiveC/MessageSendTests.cs     | 10 ----------
 .../ObjectiveC/PendingExceptionTests.cs                |  5 -----
 .../tests/System/Text/StringBuilderTests.cs            |  2 --
 4 files changed, 26 deletions(-)

diff --git a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs
index 9788e6684fc018..5c8159051c66c5 100644
--- a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs
+++ b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/ConsoleLifetimeExitTests.cs
@@ -106,10 +106,6 @@ await Host.CreateDefaultBuilder()
                     })
                     .RunConsoleAsync();
             }, new RemoteInvokeOptions() { ExpectedExitCode = 124 });
-
-            // TODO: Remove once https://github.com/dotnet/arcade/issues/5865 is resolved
-            remoteHandle.Process.WaitForExit();
-            Assert.Equal(124, remoteHandle.Process.ExitCode);
         }
 
         private class EnsureEnvironmentExitCodeWorker : BackgroundService
@@ -143,11 +139,6 @@ await Host.CreateDefaultBuilder()
                     })
                     .RunConsoleAsync();
             }, new RemoteInvokeOptions() { TimeOut = 30_000, ExpectedExitCode = expectedExitCode }); // give a 30 second time out, so if this does hang, it doesn't hang for the full timeout
-
-            Assert.True(remoteHandle.Process.WaitForExit(30_000), "The hosted process should have exited within 30 seconds");
-
-            // TODO: Remove once https://github.com/dotnet/arcade/issues/5865 is resolved
-            Assert.Equal(expectedExitCode, remoteHandle.Process.ExitCode);
         }
 
         private class EnsureEnvironmentExitDoesntHangWorker : BackgroundService
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/MessageSendTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/MessageSendTests.cs
index 10104a0a0bb77a..6c45152e8fe2c7 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/MessageSendTests.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/MessageSendTests.cs
@@ -71,11 +71,6 @@ public void SetMessageSendCallback_AlreadySet()
                 var (msgSend, func) = msgSendOverrides[0];
                 ObjectiveCMarshal.SetMessageSendCallback(msgSend, func);
                 Assert.Throws<InvalidOperationException>(() => ObjectiveCMarshal.SetMessageSendCallback(msgSend, func));
-
-                // TODO: Remove once https://github.com/dotnet/arcade/issues/5865 is resolved
-                // RemoteExecutor currently only checks the expected exit code if the invoked function returns an int.
-                // Check the exit code to ensure the test will fail if there was a crash that could not be caught by the executor.
-                return RemoteExecutor.SuccessExitCode;
             }).Dispose();
         }
 
@@ -102,11 +97,6 @@ public void SetMessageSendCallback(MessageSendFunction[] funcsToOverride)
                 }
 
                 SetMessageSendCallbackImpl(msgSendArray);
-
-                // TODO: Remove once https://github.com/dotnet/arcade/issues/5865 is resolved
-                // RemoteExecutor currently only checks the expected exit code if the invoked function returns an int.
-                // Check the exit code to ensure the test will fail if there was a crash that could not be caught by the executor.
-                return RemoteExecutor.SuccessExitCode;
             }, string.Join(';', funcsToOverride)).Dispose();
         }
 
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/PendingExceptionTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/PendingExceptionTests.cs
index 5a67e3367eaff6..d60e2b6a43b374 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/PendingExceptionTests.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ObjectiveC/PendingExceptionTests.cs
@@ -59,11 +59,6 @@ public void ValidateSetMessageSendPendingException(MessageSendFunction func)
                 Assert.True(Enum.IsDefined<MessageSendFunction>(msgSend));
 
                 ValidateSetMessageSendPendingExceptionImpl(msgSend);
-
-                // TODO: Remove once https://github.com/dotnet/arcade/issues/5865 is resolved
-                // RemoteExecutor currently only checks the expected exit code if the invoked function returns an int.
-                // Check the exit code to ensure the test will fail if there was a crash that could not be caught by the executor.
-                return RemoteExecutor.SuccessExitCode;
             }, func.ToString()).Dispose();
         }
 
diff --git a/src/libraries/System.Runtime/tests/System/Text/StringBuilderTests.cs b/src/libraries/System.Runtime/tests/System/Text/StringBuilderTests.cs
index 89bf734808fe28..23f37e4949ab44 100644
--- a/src/libraries/System.Runtime/tests/System/Text/StringBuilderTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Text/StringBuilderTests.cs
@@ -2268,8 +2268,6 @@ public static unsafe void FailureOnLargeString()
                     string s = new string('x', 500_000_000);
                     sb.Append(s); // This should throw, not AV
                 });
-
-                return RemoteExecutor.SuccessExitCode; // workaround https://github.com/dotnet/arcade/issues/5865
             }).Dispose();
         }
     }

From ac0a35b063c7767618468636b782b19a632393b2 Mon Sep 17 00:00:00 2001
From: Tlakaelel Axayakatl Ceja <tlakaelel.ceja@microsoft.com>
Date: Wed, 26 Jan 2022 21:13:24 -0800
Subject: [PATCH 103/161] Simplify the creation of diagnostics using
 DiagnosticId (#64250)

Simplify the creation of diagnostics using DiagnosticId
Add missing NativeAOT DiagnosticId, resource message, and resource title
Refactor code to use new diagnostic overloads
Add overloads to log errors
Change IL1005 from a warning to an error
Add resilient mode option to NativeAOT
Add ability to create informational messages
---
 .../Microsoft.NETCore.Native.targets          |  1 +
 .../Common/Compiler/CompilationBuilder.cs     |  7 ++
 src/coreclr/tools/Common/Compiler/Logger.cs   | 74 ++++++++++++++++--
 .../Compiler/Logging/MessageContainer.cs      | 64 ++++++++++++++-
 .../ReferenceSource/CompilerGeneratedState.cs | 15 ++--
 ...mentationSignatureGenerator.PartVisitor.cs |  6 +-
 .../DocumentationSignatureParser.cs           |  3 -
 .../ReferenceSource/MessageContainer.cs       | 78 +++++++++++++++++--
 .../Logging/ReferenceSource/MessageOrigin.cs  | 44 ++++++-----
 .../Logging/ReferenceSource/README.md         |  2 +-
 .../Compiler/Dataflow/FlowAnnotations.cs      | 66 +++++-----------
 .../Dataflow/ReflectionMethodBodyScanner.cs   | 33 ++------
 .../Compiler/LazyGenerics/ModuleCycleInfo.cs  |  9 +--
 .../Compiler/UsageBasedInteropStubManager.cs  |  7 +-
 .../Compiler/UsageBasedMetadataManager.cs     |  8 +-
 .../ReadyToRunCodegenCompilationBuilder.cs    |  7 --
 .../Compiler/RyuJitCompilation.cs             | 11 ++-
 .../Compiler/RyuJitCompilationBuilder.cs      |  3 +
 src/coreclr/tools/aot/ILCompiler/Program.cs   |  5 ++
 .../tools/aot/ILLink.Shared/DiagnosticId.cs   | 15 ++--
 .../aot/ILLink.Shared/SharedStrings.resx      | 34 ++++++--
 src/coreclr/tools/aot/crossgen2/Program.cs    |  2 +-
 22 files changed, 325 insertions(+), 169 deletions(-)

diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
index 8fc0d8e6842e90..529de6be54f554 100644
--- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
+++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets
@@ -242,6 +242,7 @@ The .NET Foundation licenses this file to you under the MIT license.
       <IlcArg Include="@(_IlcTrimmedAssemblies->'--trim:%(Identity)')" />
       <IlcArg Include="@(_IlcNoSingleWarnAssemblies->'--nosinglewarnassembly:%(Filename)')" />
       <IlcArg Condition="'$(TrimmerDefaultAction)' == 'copyused' or '$(TrimmerDefaultAction)' == 'copy'" Include="--defaultrooting" />
+      <IlcArg Include="--resilient" />
 
       <IlcArg Condition="$(IlcDisableReflection) == 'true'" Include="--feature:System.Reflection.IsReflectionExecutionAvailable=false" />
 
diff --git a/src/coreclr/tools/Common/Compiler/CompilationBuilder.cs b/src/coreclr/tools/Common/Compiler/CompilationBuilder.cs
index b246a9847f2274..5357e2f68234ba 100644
--- a/src/coreclr/tools/Common/Compiler/CompilationBuilder.cs
+++ b/src/coreclr/tools/Common/Compiler/CompilationBuilder.cs
@@ -24,6 +24,7 @@ public abstract partial class CompilationBuilder
         protected IEnumerable<ICompilationRootProvider> _compilationRoots = Array.Empty<ICompilationRootProvider>();
         protected OptimizationMode _optimizationMode = OptimizationMode.None;
         protected int _parallelism = -1;
+        protected bool _resilient;
 
         public CompilationBuilder(CompilerTypeSystemContext context, CompilationModuleGroup compilationGroup, NameMangler nameMangler)
         {
@@ -72,6 +73,12 @@ public CompilationBuilder UseOptimizationMode(OptimizationMode mode)
             return this;
         }
 
+        public CompilationBuilder UseResilience(bool resilient)
+        {
+            _resilient = resilient;
+            return this;
+        }
+
         public abstract CompilationBuilder UseBackendOptions(IEnumerable<string> options);
 
         public abstract CompilationBuilder UseILProvider(ILProvider ilProvider);
diff --git a/src/coreclr/tools/Common/Compiler/Logger.cs b/src/coreclr/tools/Common/Compiler/Logger.cs
index 26f763b815595f..5ecd5e846c4be3 100644
--- a/src/coreclr/tools/Common/Compiler/Logger.cs
+++ b/src/coreclr/tools/Common/Compiler/Logger.cs
@@ -48,6 +48,13 @@ public Logger(TextWriter writer, bool isVerbose)
         {
         }
 
+        public void LogMessage(string message)
+        {
+            MessageContainer? messageContainer = MessageContainer.CreateInfoMessage(message);
+            if(messageContainer.HasValue)
+                Writer.WriteLine(messageContainer.Value.ToMSBuildString());
+        }
+
         public void LogWarning(string text, int code, MessageOrigin origin, string subcategory = MessageSubCategory.None)
         {
             MessageContainer? warning = MessageContainer.CreateWarningMessage(this, text, code, origin, subcategory);
@@ -55,14 +62,19 @@ public void LogWarning(string text, int code, MessageOrigin origin, string subca
                 Writer.WriteLine(warning.Value.ToMSBuildString());
         }
 
-        public void LogWarning(string text, int code, TypeSystemEntity origin, string subcategory = MessageSubCategory.None)
+        public void LogWarning(MessageOrigin origin, DiagnosticId id, params string[] args)
         {
-            MessageOrigin messageOrigin = new MessageOrigin(origin);
-            MessageContainer? warning = MessageContainer.CreateWarningMessage(this, text, code, messageOrigin, subcategory);
+            MessageContainer? warning = MessageContainer.CreateWarningMessage(this, origin, id, args);
             if (warning.HasValue)
                 Writer.WriteLine(warning.Value.ToMSBuildString());
         }
 
+        public void LogWarning(string text, int code, TypeSystemEntity origin, string subcategory = MessageSubCategory.None) =>
+            LogWarning(text, code, new MessageOrigin(origin), subcategory);
+
+        public void LogWarning(TypeSystemEntity origin, DiagnosticId id, params string[] args) =>
+            LogWarning(new MessageOrigin(origin), id, args);
+
         public void LogWarning(string text, int code, MethodIL origin, int ilOffset, string subcategory = MessageSubCategory.None)
         {
             string document = null;
@@ -87,12 +99,62 @@ public void LogWarning(string text, int code, MethodIL origin, int ilOffset, str
             LogWarning(text, code, messageOrigin, subcategory);
         }
 
+        public void LogWarning(MethodIL origin, int ilOffset, DiagnosticId id, params string[] args)
+        {
+            string document = null;
+            int? lineNumber = null;
+
+            IEnumerable<ILSequencePoint> sequencePoints = origin.GetDebugInfo()?.GetSequencePoints();
+            if (sequencePoints != null)
+            {
+                foreach (var sequencePoint in sequencePoints)
+                {
+                    if (sequencePoint.Offset <= ilOffset)
+                    {
+                        document = sequencePoint.Document;
+                        lineNumber = sequencePoint.LineNumber;
+                    }
+                }
+            }
+
+            MethodDesc warnedMethod = CompilerGeneratedState.GetUserDefinedMethodForCompilerGeneratedMember(origin.OwningMethod) ?? origin.OwningMethod;
+
+            MessageOrigin messageOrigin = new MessageOrigin(warnedMethod, document, lineNumber, null);
+            LogWarning(messageOrigin, id, args);
+        }
+
         public void LogWarning(string text, int code, string origin, string subcategory = MessageSubCategory.None)
         {
             MessageOrigin _origin = new MessageOrigin(origin);
             LogWarning(text, code, _origin, subcategory);
         }
 
+        public void LogWarning(string origin, DiagnosticId id, params string[] args)
+        {
+            MessageOrigin _origin = new MessageOrigin(origin);
+            LogWarning(_origin, id, args);
+        }
+
+        public void LogError(string text, int code, string subcategory = MessageSubCategory.None, MessageOrigin? origin = null)
+        {
+            MessageContainer? error = MessageContainer.CreateErrorMessage(text, code, subcategory, origin);
+            if (error.HasValue)
+                Writer.WriteLine(error.Value.ToMSBuildString());
+        }
+
+        public void LogError(MessageOrigin? origin, DiagnosticId id, params string[] args)
+        {
+            MessageContainer? error = MessageContainer.CreateErrorMessage(origin, id, args);
+            if (error.HasValue)
+                Writer.WriteLine(error.Value.ToMSBuildString());
+        }
+
+        public void LogError(string text, int code, TypeSystemEntity origin, string subcategory = MessageSubCategory.None) =>
+            LogError(text, code, subcategory, new MessageOrigin(origin));
+
+        public void LogError(TypeSystemEntity origin, DiagnosticId id, params string[] args) =>
+            LogError(new MessageOrigin(origin), id, args);
+
         internal bool IsWarningSuppressed(int code, MessageOrigin origin)
         {
             // This is causing too much noise
@@ -168,7 +230,7 @@ internal bool IsSingleWarn(ModuleDesc owningModule, string messageSubcategory)
                     {
                         if (_trimWarnedAssemblies.Add(assemblyName))
                         {
-                            LogWarning($"Assembly '{assemblyName}' produced trim warnings. For more information see https://aka.ms/dotnet-illink/libraries", 2104, GetModuleFileName(owningModule));
+                            LogWarning(GetModuleFileName(owningModule), DiagnosticId.AssemblyProducedTrimWarnings, assemblyName);
                         }
                     }
                 }
@@ -178,12 +240,12 @@ internal bool IsSingleWarn(ModuleDesc owningModule, string messageSubcategory)
                     {
                         if (_aotWarnedAssemblies.Add(assemblyName))
                         {
-                            LogWarning($"Assembly '{assemblyName}' produced AOT analysis warnings.", 3053, GetModuleFileName(owningModule));
+                            LogWarning(GetModuleFileName(owningModule), DiagnosticId.AssemblyProducedAOTWarnings, assemblyName);
                         }
                     }
                 }
             }
-            
+
             return result;
         }
 
diff --git a/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs b/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs
index ebe08a14870ed2..060315e3455558 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs
+++ b/src/coreclr/tools/Common/Compiler/Logging/MessageContainer.cs
@@ -67,6 +67,22 @@ internal static MessageContainer CreateErrorMessage(string text, int code, strin
             return new MessageContainer(MessageCategory.Error, text, code, subcategory, origin);
         }
 
+        /// <summary>
+        /// Create an error message.
+        /// </summary>
+        /// <param name="origin">Filename, line, and column where the error was found</param>
+        /// <param name="id">Unique error ID. Please see https://github.com/dotnet/linker/blob/main/docs/error-codes.md
+        /// for the list of errors and possibly add a new one</param>
+        /// <param name="args">Additional arguments to form a humanly readable message describing the warning</param>
+        /// <returns>New MessageContainer of 'Error' category</returns>
+        internal static MessageContainer CreateErrorMessage(MessageOrigin? origin, DiagnosticId id, params string[] args)
+        {
+            if (!((int)id >= 1000 && (int)id <= 2000))
+                throw new ArgumentOutOfRangeException(nameof(id), $"The provided code '{(int)id}' does not fall into the error category, which is in the range of 1000 to 2000 (inclusive).");
+
+            return new MessageContainer(MessageCategory.Error, id, origin: origin, args: args);
+        }
+
         /// <summary>
         /// Create a warning message.
         /// </summary>
@@ -81,12 +97,29 @@ internal static MessageContainer CreateErrorMessage(string text, int code, strin
         /// <returns>New MessageContainer of 'Warning' category</returns>
         internal static MessageContainer? CreateWarningMessage(Logger context, string text, int code, MessageOrigin origin, string subcategory = MessageSubCategory.None)
         {
-            //if (!(code > 2000 && code <= 6000))
-            //    throw new ArgumentOutOfRangeException(nameof(code), $"The provided code '{code}' does not fall into the warning category, which is in the range of 2001 to 6000 (inclusive).");
+            if (!(code > 2000 && code <= 6000))
+                throw new ArgumentOutOfRangeException(nameof(code), $"The provided code '{code}' does not fall into the warning category, which is in the range of 2001 to 6000 (inclusive).");
 
             return CreateWarningMessageContainer(context, text, code, origin, subcategory);
         }
 
+        /// <summary>
+        /// Create a warning message.
+        /// </summary>
+        /// <param name="context">Context with the relevant warning suppression info.</param>
+        /// <param name="origin">Filename or member where the warning is coming from</param>
+        /// <param name="id">Unique warning ID. Please see https://github.com/dotnet/linker/blob/main/docs/error-codes.md
+        /// for the list of warnings and possibly add a new one</param>
+        /// <param name="args">Additional arguments to form a humanly readable message describing the warning</param>
+        /// <returns>New MessageContainer of 'Warning' category</returns>
+        internal static MessageContainer? CreateWarningMessage(Logger context, MessageOrigin origin, DiagnosticId id, params string[] args)
+        {
+            if (!((int)id > 2000 && (int)id <= 6000))
+                throw new ArgumentOutOfRangeException(nameof(id), $"The provided code '{(int)id}' does not fall into the warning category, which is in the range of 2001 to 6000 (inclusive).");
+
+            return CreateWarningMessageContainer(context, origin, id, id.GetDiagnosticSubcategory(), args);
+        }
+
         private static MessageContainer? CreateWarningMessageContainer(Logger context, string text, int code, MessageOrigin origin, string subcategory = MessageSubCategory.None)
         {
             if (context.IsWarningSuppressed(code, origin))
@@ -101,6 +134,20 @@ internal static MessageContainer CreateErrorMessage(string text, int code, strin
             return new MessageContainer(MessageCategory.Warning, text, code, subcategory, origin);
         }
 
+        private static MessageContainer? CreateWarningMessageContainer(Logger context, MessageOrigin origin, DiagnosticId id, string subcategory, params string[] args)
+        {
+            if (context.IsWarningSuppressed((int)id, origin))
+                return null;
+
+            if (TryLogSingleWarning(context, (int)id, origin, subcategory))
+                return null;
+
+            if (context.IsWarningAsError((int)id))
+                return new MessageContainer(MessageCategory.WarningAsError, id, subcategory, origin, args);
+
+            return new MessageContainer(MessageCategory.Warning, id, subcategory, origin, args);
+        }
+
         private static bool TryLogSingleWarning(Logger context, int code, MessageOrigin origin, string subcategory)
         {
             if (subcategory != MessageSubCategory.AotAnalysis && subcategory != MessageSubCategory.TrimAnalysis)
@@ -137,7 +184,7 @@ private static bool TryLogSingleWarning(Logger context, int code, MessageOrigin
         private static bool IsTrimmableAssembly(ModuleDesc assembly)
         {
             if (assembly is EcmaAssembly ecmaAssembly)
-            {   
+            {
                 foreach (var attribute in ecmaAssembly.GetDecodedCustomAttributes("System.Reflection", "AssemblyMetadataAttribute"))
                 {
                     if (attribute.FixedArguments.Length != 2)
@@ -195,6 +242,15 @@ private MessageContainer(MessageCategory category, string text, int? code, strin
             Text = text;
         }
 
+        private MessageContainer(MessageCategory category, DiagnosticId id, string subcategory = MessageSubCategory.None, MessageOrigin? origin = null, params string[] args)
+        {
+            Code = (int)id;
+            Category = category;
+            Origin = origin;
+            SubCategory = subcategory;
+            Text = new DiagnosticString(id).GetMessage(args);
+        }
+
         public override string ToString() => ToMSBuildString();
 
         public string ToMSBuildString()
@@ -240,7 +296,7 @@ public string ToMSBuildString()
             {
                 if (Origin?.MemberDefinition is MethodDesc method)
                     sb.Append(method.GetDisplayName());
-                else 
+                else
                     sb.Append(Origin?.MemberDefinition.ToString());
 
                 sb.Append(": ");
diff --git a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/CompilerGeneratedState.cs b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/CompilerGeneratedState.cs
index 34821288b76d9d..3c22da1f5478b1 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/CompilerGeneratedState.cs
+++ b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/CompilerGeneratedState.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using ILLink.Shared;
 using Mono.Cecil;
 
 namespace Mono.Linker
@@ -41,15 +42,11 @@ void PopulateCacheForType (TypeDefinition type)
 					case "AsyncIteratorStateMachineAttribute":
 					case "AsyncStateMachineAttribute":
 					case "IteratorStateMachineAttribute":
-						TypeDefinition stateMachineType = GetFirstConstructorArgumentAsType (attribute);
+						TypeDefinition? stateMachineType = GetFirstConstructorArgumentAsType (attribute);
 						if (stateMachineType != null) {
 							if (!_compilerGeneratedTypeToUserCodeMethod.TryAdd (stateMachineType, method)) {
 								var alreadyAssociatedMethod = _compilerGeneratedTypeToUserCodeMethod[stateMachineType];
-								_context.LogWarning (
-									$"Methods '{method.GetDisplayName ()}' and '{alreadyAssociatedMethod.GetDisplayName ()}' are both associated with state machine type '{stateMachineType.GetDisplayName ()}'. This is currently unsupported and may lead to incorrectly reported warnings.",
-									2107,
-									new MessageOrigin (method),
-									MessageSubCategory.TrimAnalysis);
+								_context.LogWarning (new MessageOrigin (method), DiagnosticId.MethodsAreAssociatedWithStateMachine, method.GetDisplayName (), alreadyAssociatedMethod.GetDisplayName (), stateMachineType.GetDisplayName ());
 							}
 						}
 
@@ -59,7 +56,7 @@ void PopulateCacheForType (TypeDefinition type)
 			}
 		}
 
-		static TypeDefinition GetFirstConstructorArgumentAsType (CustomAttribute attribute)
+		static TypeDefinition? GetFirstConstructorArgumentAsType (CustomAttribute attribute)
 		{
 			if (!attribute.HasConstructorArguments)
 				return null;
@@ -67,13 +64,13 @@ static TypeDefinition GetFirstConstructorArgumentAsType (CustomAttribute attribu
 			return attribute.ConstructorArguments[0].Value as TypeDefinition;
 		}
 
-		public MethodDefinition GetUserDefinedMethodForCompilerGeneratedMember (IMemberDefinition sourceMember)
+		public MethodDefinition? GetUserDefinedMethodForCompilerGeneratedMember (IMemberDefinition sourceMember)
 		{
 			if (sourceMember == null)
 				return null;
 
 			TypeDefinition compilerGeneratedType = (sourceMember as TypeDefinition) ?? sourceMember.DeclaringType;
-			if (_compilerGeneratedTypeToUserCodeMethod.TryGetValue (compilerGeneratedType, out MethodDefinition userDefinedMethod))
+			if (_compilerGeneratedTypeToUserCodeMethod.TryGetValue (compilerGeneratedType, out MethodDefinition? userDefinedMethod))
 				return userDefinedMethod;
 
 			// Only handle async or iterator state machine
diff --git a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureGenerator.PartVisitor.cs b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureGenerator.PartVisitor.cs
index ed4763b75cda81..65211abd93c074 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureGenerator.PartVisitor.cs
+++ b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureGenerator.PartVisitor.cs
@@ -1,6 +1,5 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
 
 using System;
 using System.Collections.Generic;
@@ -147,7 +146,10 @@ public void VisitTypeReference (TypeReference typeReference, StringBuilder build
 				}
 
 				if (typeReference.IsNested) {
-					VisitTypeReference (typeReference.GetInflatedDeclaringType (resolver), builder, resolver);
+					Debug.Assert (typeReference is not SentinelType && typeReference is not PinnedType);
+					// GetInflatedDeclaringType may return null for generic parameters, byrefs, and pointers, but these
+					// are separately handled above.
+					VisitTypeReference (typeReference.GetInflatedDeclaringType (resolver)!, builder, resolver);
 					builder.Append ('.');
 				}
 
diff --git a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureParser.cs b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureParser.cs
index 923197f58b6bf0..8a6594e47f2052 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureParser.cs
+++ b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/DocumentationSignatureParser.cs
@@ -1,8 +1,5 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#nullable enable
 
 using System;
 using System.Collections.Generic;
diff --git a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageContainer.cs b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageContainer.cs
index f0a4afd09b1875..69fb968c4ef9ce 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageContainer.cs
+++ b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageContainer.cs
@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Text;
+using ILLink.Shared;
 using Mono.Cecil;
 
 namespace Mono.Linker
@@ -54,6 +55,22 @@ internal static MessageContainer CreateErrorMessage (string text, int code, stri
 			return new MessageContainer (MessageCategory.Error, text, code, subcategory, origin);
 		}
 
+		/// <summary>
+		/// Create an error message.
+		/// </summary>
+		/// <param name="origin">Filename, line, and column where the error was found</param>
+		/// <param name="id">Unique error ID. Please see https://github.com/dotnet/linker/blob/main/docs/error-codes.md
+		/// for the list of errors and possibly add a new one</param>
+		/// <param name="args">Additional arguments to form a humanly readable message describing the warning</param>
+		/// <returns>New MessageContainer of 'Error' category</returns>
+		internal static MessageContainer CreateErrorMessage (MessageOrigin? origin, DiagnosticId id, params string[] args)
+		{
+			if (!((int) id >= 1000 && (int) id <= 2000))
+				throw new ArgumentOutOfRangeException (nameof (id), $"The provided code '{(int) id}' does not fall into the error category, which is in the range of 1000 to 2000 (inclusive).");
+
+			return new MessageContainer (MessageCategory.Error, id, origin: origin, args: args);
+		}
+
 		/// <summary>
 		/// Create a custom error message.
 		/// </summary>
@@ -96,6 +113,25 @@ internal static MessageContainer CreateWarningMessage (LinkContext context, stri
 			return CreateWarningMessageContainer (context, text, code, origin, version, subcategory);
 		}
 
+		/// <summary>
+		/// Create a warning message.
+		/// </summary>
+		/// <param name="context">Context with the relevant warning suppression info.</param>
+		/// <param name="origin">Filename or member where the warning is coming from</param>
+		/// <param name="id">Unique warning ID. Please see https://github.com/dotnet/linker/blob/main/docs/error-codes.md
+		/// for the list of warnings and possibly add a new one</param>
+		/// <param name="version">Optional warning version number. Versioned warnings can be controlled with the
+		/// warning wave option --warn VERSION. Unversioned warnings are unaffected by this option. </param>
+		/// <param name="args">Additional arguments to form a humanly readable message describing the warning</param>
+		/// <returns>New MessageContainer of 'Warning' category</returns>
+		internal static MessageContainer CreateWarningMessage (LinkContext context, MessageOrigin origin, DiagnosticId id, WarnVersion version, params string[] args)
+		{
+			if (!((int) id > 2000 && (int) id <= 6000))
+				throw new ArgumentOutOfRangeException (nameof (id), $"The provided code '{(int) id}' does not fall into the warning category, which is in the range of 2001 to 6000 (inclusive).");
+
+			return CreateWarningMessageContainer (context, origin, id, version, id.GetDiagnosticSubcategory (), args);
+		}
+
 		/// <summary>
 		/// Create a custom warning message.
 		/// </summary>
@@ -141,6 +177,26 @@ private static MessageContainer CreateWarningMessageContainer (LinkContext conte
 			return new MessageContainer (MessageCategory.Warning, text, code, subcategory, origin);
 		}
 
+		private static MessageContainer CreateWarningMessageContainer (LinkContext context, MessageOrigin origin, DiagnosticId id, WarnVersion version, string subcategory, params string[] args)
+		{
+			if (!(version >= WarnVersion.ILLink0 && version <= WarnVersion.Latest))
+				throw new ArgumentException ($"The provided warning version '{version}' is invalid.");
+
+			if (context.IsWarningSuppressed ((int) id, origin))
+				return Empty;
+
+			if (version > context.WarnVersion)
+				return Empty;
+
+			if (TryLogSingleWarning (context, (int) id, origin, subcategory))
+				return Empty;
+
+			if (context.IsWarningAsError ((int) id))
+				return new MessageContainer (MessageCategory.WarningAsError, id, subcategory, origin, args);
+
+			return new MessageContainer (MessageCategory.Warning, id, subcategory, origin, args);
+		}
+
 		public bool IsWarningMessage ([NotNullWhen (true)] out int? code)
 		{
 			code = null;
@@ -159,15 +215,16 @@ static bool TryLogSingleWarning (LinkContext context, int code, MessageOrigin or
 			if (subcategory != MessageSubCategory.TrimAnalysis)
 				return false;
 
-			Debug.Assert (origin.Provider != null);
+			// There are valid cases where we can't map the message to an assembly
+			// For example if it's caused by something in an xml file passed on the command line
+			// In that case, give up on single-warn collapse and just print out the warning on its own.
 			var assembly = origin.Provider switch {
 				AssemblyDefinition asm => asm,
 				TypeDefinition type => type.Module.Assembly,
 				IMemberDefinition member => member.DeclaringType.Module.Assembly,
-				_ => throw new NotSupportedException ()
+				_ => null
 			};
 
-			Debug.Assert (assembly != null);
 			if (assembly == null)
 				return false;
 
@@ -181,7 +238,7 @@ static bool TryLogSingleWarning (LinkContext context, int code, MessageOrigin or
 				return false;
 
 			if (context.AssembliesWithGeneratedSingleWarning.Add (assemblyName))
-				context.LogWarning ($"Assembly '{assemblyName}' produced trim warnings. For more information see https://aka.ms/dotnet-illink/libraries", 2104, context.GetAssemblyLocation (assembly));
+				context.LogWarning (context.GetAssemblyLocation (assembly), DiagnosticId.AssemblyProducedTrimWarnings, assemblyName);
 
 			return true;
 		}
@@ -215,6 +272,15 @@ private MessageContainer (MessageCategory category, string text, int? code, stri
 			Text = text;
 		}
 
+		private MessageContainer (MessageCategory category, DiagnosticId id, string subcategory = MessageSubCategory.None, MessageOrigin? origin = null, params string[] args)
+		{
+			Code = (int) id;
+			Category = category;
+			Origin = origin;
+			SubCategory = subcategory;
+			Text = new DiagnosticString (id).GetMessage (args);
+		}
+
 		public override string ToString () => ToMSBuildString ();
 
 		public string ToMSBuildString ()
@@ -256,6 +322,8 @@ public string ToMSBuildString ()
 			if (Origin?.Provider != null) {
 				if (Origin?.Provider is MethodDefinition method)
 					sb.Append (method.GetDisplayName ());
+				else if (Origin?.Provider is MemberReference memberRef)
+					sb.Append (memberRef.GetDisplayName ());
 				else if (Origin?.Provider is IMemberDefinition member)
 					sb.Append (member.FullName);
 				else if (Origin?.Provider is AssemblyDefinition assembly)
@@ -274,7 +342,7 @@ public string ToMSBuildString ()
 		public bool Equals (MessageContainer other) =>
 			(Category, Text, Code, SubCategory, Origin) == (other.Category, other.Text, other.Code, other.SubCategory, other.Origin);
 
-		public override bool Equals (object obj) => obj is MessageContainer messageContainer && Equals (messageContainer);
+		public override bool Equals (object? obj) => obj is MessageContainer messageContainer && Equals (messageContainer);
 		public override int GetHashCode () => (Category, Text, Code, SubCategory, Origin).GetHashCode ();
 
 		public int CompareTo (MessageContainer other)
diff --git a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageOrigin.cs b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageOrigin.cs
index 84357b26ae221d..62de5fb3268fb0 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageOrigin.cs
+++ b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/MessageOrigin.cs
@@ -12,49 +12,55 @@ namespace Mono.Linker
 {
 	public readonly struct MessageOrigin : IComparable<MessageOrigin>, IEquatable<MessageOrigin>
 	{
-#nullable enable
 		public string? FileName { get; }
 		public ICustomAttributeProvider? Provider { get; }
-		readonly ICustomAttributeProvider _suppressionContextMember;
+		readonly ICustomAttributeProvider? _suppressionContextMember;
 		public ICustomAttributeProvider? SuppressionContextMember {
 			get {
 				Debug.Assert (_suppressionContextMember == null || _suppressionContextMember is IMemberDefinition || _suppressionContextMember is AssemblyDefinition);
 				return _suppressionContextMember ?? Provider;
 			}
 		}
-#nullable disable
+
 		public int SourceLine { get; }
 		public int SourceColumn { get; }
 		public int? ILOffset { get; }
 
 		const int HiddenLineNumber = 0xfeefee;
 
-		public MessageOrigin (IMemberDefinition memberDefinition, int? ilOffset = null)
+		public MessageOrigin (IMemberDefinition? memberDefinition, int? ilOffset = null)
 			: this (memberDefinition as ICustomAttributeProvider, ilOffset)
 		{
 		}
 
-		public MessageOrigin (ICustomAttributeProvider provider)
+		public MessageOrigin (ICustomAttributeProvider? provider)
 			: this (provider, null)
 		{
 		}
 
 		public MessageOrigin (string fileName, int sourceLine = 0, int sourceColumn = 0)
+			: this (fileName, sourceLine, sourceColumn, null)
+		{
+		}
+
+		// The assembly attribute should be specified if available as it allows assigning the diagnostic
+		// to a an assembly (we group based on assembly).
+		public MessageOrigin (string fileName, int sourceLine, int sourceColumn, AssemblyDefinition? assembly)
 		{
 			FileName = fileName;
 			SourceLine = sourceLine;
 			SourceColumn = sourceColumn;
-			Provider = null;
+			Provider = assembly;
 			_suppressionContextMember = null;
 			ILOffset = null;
 		}
 
-		public MessageOrigin (ICustomAttributeProvider provider, int? ilOffset)
+		public MessageOrigin (ICustomAttributeProvider? provider, int? ilOffset)
 			: this (provider, ilOffset, null)
 		{
 		}
 
-		public MessageOrigin (ICustomAttributeProvider provider, int? ilOffset, ICustomAttributeProvider suppressionContextMember)
+		public MessageOrigin (ICustomAttributeProvider? provider, int? ilOffset, ICustomAttributeProvider? suppressionContextMember)
 		{
 			Debug.Assert (provider == null || provider is IMemberDefinition || provider is AssemblyDefinition);
 			Debug.Assert (suppressionContextMember == null || suppressionContextMember is IMemberDefinition || provider is AssemblyDefinition);
@@ -66,7 +72,7 @@ public MessageOrigin (ICustomAttributeProvider provider, int? ilOffset, ICustomA
 			ILOffset = ilOffset;
 		}
 
-		public MessageOrigin (MessageOrigin other, IMemberDefinition suppressionContextMember)
+		public MessageOrigin (MessageOrigin other, IMemberDefinition? suppressionContextMember)
 		{
 			FileName = other.FileName;
 			Provider = other.Provider;
@@ -76,21 +82,21 @@ public MessageOrigin (MessageOrigin other, IMemberDefinition suppressionContextM
 			ILOffset = other.ILOffset;
 		}
 
-		public override string ToString ()
+		public override string? ToString ()
 		{
 			int sourceLine = SourceLine, sourceColumn = SourceColumn;
-			string fileName = FileName;
+			string? fileName = FileName;
 			if (Provider is MethodDefinition method &&
 				method.DebugInformation.HasSequencePoints) {
 				var offset = ILOffset ?? 0;
-				SequencePoint correspondingSequencePoint = method.DebugInformation.SequencePoints
+				SequencePoint? correspondingSequencePoint = method.DebugInformation.SequencePoints
 					.Where (s => s.Offset <= offset)?.Last ();
 
 				// If the warning comes from hidden line (compiler generated code typically)
 				// search for any sequence point with non-hidden line number and report that as a best effort.
-				if (correspondingSequencePoint.StartLine == HiddenLineNumber) {
+				if (correspondingSequencePoint?.StartLine == HiddenLineNumber) {
 					correspondingSequencePoint = method.DebugInformation.SequencePoints
-						.Where (s => s.StartLine != HiddenLineNumber)?.FirstOrDefault ();
+						.Where (s => s.StartLine != HiddenLineNumber).FirstOrDefault ();
 				}
 
 				if (correspondingSequencePoint != null) {
@@ -118,7 +124,7 @@ public override string ToString ()
 		public bool Equals (MessageOrigin other) =>
 			(FileName, Provider, SourceLine, SourceColumn, ILOffset) == (other.FileName, other.Provider, other.SourceLine, other.SourceColumn, other.ILOffset);
 
-		public override bool Equals (object obj) => obj is MessageOrigin messageOrigin && Equals (messageOrigin);
+		public override bool Equals (object? obj) => obj is MessageOrigin messageOrigin && Equals (messageOrigin);
 		public override int GetHashCode () => (FileName, Provider, SourceLine, SourceColumn).GetHashCode ();
 		public static bool operator == (MessageOrigin lhs, MessageOrigin rhs) => lhs.Equals (rhs);
 		public static bool operator != (MessageOrigin lhs, MessageOrigin rhs) => !lhs.Equals (rhs);
@@ -128,12 +134,12 @@ public int CompareTo (MessageOrigin other)
 			if (Provider != null && other.Provider != null) {
 				var thisMember = Provider as IMemberDefinition;
 				var otherMember = other.Provider as IMemberDefinition;
-				TypeDefinition thisTypeDef = (Provider as TypeDefinition) ?? (Provider as IMemberDefinition)?.DeclaringType;
-				TypeDefinition otherTypeDef = (other.Provider as TypeDefinition) ?? (other.Provider as IMemberDefinition)?.DeclaringType;
+				TypeDefinition? thisTypeDef = (Provider as TypeDefinition) ?? (Provider as IMemberDefinition)?.DeclaringType;
+				TypeDefinition? otherTypeDef = (other.Provider as TypeDefinition) ?? (other.Provider as IMemberDefinition)?.DeclaringType;
 				var thisAssembly = thisTypeDef?.Module.Assembly ?? Provider as AssemblyDefinition;
 				var otherAssembly = otherTypeDef?.Module.Assembly ?? other.Provider as AssemblyDefinition;
-				int result = (thisAssembly.Name.Name, thisTypeDef?.Name, thisMember?.Name).CompareTo
-					((otherAssembly.Name.Name, otherTypeDef?.Name, otherMember?.Name));
+				int result = (thisAssembly?.Name.Name, thisTypeDef?.Name, thisMember?.Name).CompareTo
+					((otherAssembly?.Name.Name, otherTypeDef?.Name, otherMember?.Name));
 				if (result != 0)
 					return result;
 
diff --git a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/README.md b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/README.md
index 883332600e88d0..4fdfbf1c1fdac3 100644
--- a/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/README.md
+++ b/src/coreclr/tools/Common/Compiler/Logging/ReferenceSource/README.md
@@ -1 +1 @@
-Sources from the dotnet/linker repo at commit c0567db0b9088e2ad4144cd0fe2a985611ec28f0.
+Sources from the dotnet/linker repo at commit 2999a6a9dd884d554be18d3c86a4a9db4b61e156.
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs
index 64ce9a5ba1218c..6e659a95eb7e79 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs
@@ -289,9 +289,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
                     if (!IsTypeInterestingForDataflow(field.FieldType))
                     {
                         // Already know that there's a non-empty annotation on a field which is not System.Type/String and we're about to ignore it
-                        _logger.LogWarning(
-                            $"Field '{field.GetDisplayName()}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to fields of type 'System.Type' or 'System.String'.",
-                            2097, field, subcategory: MessageSubCategory.TrimAnalysis);
+                        _logger.LogWarning(field, DiagnosticId.DynamicallyAccessedMembersOnFieldCanOnlyApplyToTypesOrStrings, field.GetDisplayName());
                         continue;
                     }
 
@@ -343,9 +341,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
                         }
                         else
                         {
-                            _logger.LogWarning(
-                                $"The 'DynamicallyAccessedMembersAttribute' is not allowed on methods. It is allowed on method return value or method parameters though.",
-                                2041, method, subcategory: MessageSubCategory.TrimAnalysis);
+                            _logger.LogWarning(method, DiagnosticId.DynamicallyAccessedMembersIsNotAllowedOnMethods);
                         }
                     }
 
@@ -364,9 +360,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
                             returnAnnotation = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, parameter.GetCustomAttributes());
                             if (returnAnnotation != DynamicallyAccessedMemberTypes.None && !IsTypeInterestingForDataflow(signature.ReturnType))
                             {
-                                _logger.LogWarning(
-                                    $"Return type of method '{method.GetDisplayName()}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to parameters of type 'System.Type' or 'System.String'.",
-                                    2106, method, subcategory: MessageSubCategory.TrimAnalysis);
+                                _logger.LogWarning(method, DiagnosticId.DynamicallyAccessedMembersOnMethodReturnValueCanOnlyApplyToTypesOrStrings, method.GetDisplayName());
                             }
                         }
                         else
@@ -377,9 +371,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
 
                             if (!IsTypeInterestingForDataflow(signature[parameter.SequenceNumber - 1]))
                             {
-                                _logger.LogWarning(
-                                    $"Parameter #{parameter.SequenceNumber} of method '{method.GetDisplayName()}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to parameters of type 'System.Type' or 'System.String'.",
-                                    2098, method, subcategory: MessageSubCategory.TrimAnalysis);
+                                _logger.LogWarning(method, DiagnosticId.DynamicallyAccessedMembersOnMethodParameterCanOnlyApplyToTypesOrStrings, $"#{parameter.SequenceNumber}", method.GetDisplayName());
                                 continue;
                             }
 
@@ -435,9 +427,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
 
                     if (!IsTypeInterestingForDataflow(property.Signature.ReturnType))
                     {
-                        _logger.LogWarning(
-                            $"Property '{property.GetDisplayName()}' has 'DynamicallyAccessedMembersAttribute', but that attribute can only be applied to properties of type 'System.Type' or 'System.String'.",
-                            2099, property, subcategory: MessageSubCategory.TrimAnalysis);
+                        _logger.LogWarning(property, DiagnosticId.DynamicallyAccessedMembersOnPropertyCanOnlyApplyToTypesOrStrings, property.GetDisplayName());
                         continue;
                     }
 
@@ -462,9 +452,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
                         if (annotatedMethods.Any(a => a.Method == setMethod))
                         {
                             
-                            _logger.LogWarning(
-                                $"'DynamicallyAccessedMembersAttribute' on property '{property.GetDisplayName()}' conflicts with the same attribute on its accessor '{setMethod.GetDisplayName()}'.",
-                                2043, setMethod, subcategory: MessageSubCategory.TrimAnalysis);
+                            _logger.LogWarning(setMethod, DiagnosticId.DynamicallyAccessedMembersConflictsBetweenPropertyAndAccessor, property.GetDisplayName(), setMethod.GetDisplayName());
                         }
                         else
                         {
@@ -498,9 +486,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
 
                         if (annotatedMethods.Any(a => a.Method == getMethod))
                         {
-                            _logger.LogWarning(
-                                $"'DynamicallyAccessedMembersAttribute' on property '{property.GetDisplayName()}' conflicts with the same attribute on its accessor '{getMethod.GetDisplayName()}'.",
-                                2043, getMethod, subcategory: MessageSubCategory.TrimAnalysis);
+                            _logger.LogWarning(getMethod, DiagnosticId.DynamicallyAccessedMembersConflictsBetweenPropertyAndAccessor, property.GetDisplayName(), getMethod.GetDisplayName());
                         }
                         else
                         {
@@ -512,9 +498,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
                     if (backingFieldFromGetter != null && backingFieldFromSetter != null &&
                         backingFieldFromGetter != backingFieldFromSetter)
                     {
-                        _logger.LogWarning(
-                            $"Could not find a unique backing field for property '{property.GetDisplayName()}' to propagate 'DynamicallyAccessedMembersAttribute'.",
-                            2042, property, subcategory: MessageSubCategory.TrimAnalysis);
+                        _logger.LogWarning(property, DiagnosticId.DynamicallyAccessedMembersCouldNotFindBackingField, property.GetDisplayName());
                         backingField = null;
                     }
                     else
@@ -526,9 +510,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key)
                     {
                         if (annotatedFields.Any(a => a.Field == backingField))
                         {
-                            _logger.LogWarning(
-                                $"'DynamicallyAccessedMemberAttribute' on property '{property.GetDisplayName()}' conflicts with the same attribute on its backing field '{backingField.GetDisplayName()}'.",
-                                2056, backingField, subcategory: MessageSubCategory.TrimAnalysis);
+                            _logger.LogWarning(backingField, DiagnosticId.DynamicallyAccessedMembersOnPropertyConflictsWithBackingField, property.GetDisplayName(), backingField.GetDisplayName());
                         }
                         else
                         {
@@ -731,33 +713,23 @@ void LogValidationWarning(object provider, object baseProvider, MethodDesc origi
             switch (provider)
             {
                 case int parameterNumber:
-                    _logger.LogWarning(
-                        $"'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the parameter #{parameterNumber} of method '{DiagnosticUtilities.GetMethodSignatureDisplayName(origin)}' " +
-                        $"don't match overridden parameter #{parameterNumber} of method '{DiagnosticUtilities.GetMethodSignatureDisplayName((MethodDesc)baseProvider)}'. " +
-                        $"All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.",
-                        2092, origin, subcategory: MessageSubCategory.TrimAnalysis);
+                    _logger.LogWarning(origin, DiagnosticId.DynamicallyAccessedMembersMismatchOnMethodParameterBetweenOverrides,
+                        $"#{parameterNumber}", DiagnosticUtilities.GetMethodSignatureDisplayName(origin),
+                        $"#{parameterNumber}", DiagnosticUtilities.GetMethodSignatureDisplayName((MethodDesc)baseProvider));
                     break;
                 case GenericParameterDesc genericParameterOverride:
-                    _logger.LogWarning(
-                        $"'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the generic parameter '{genericParameterOverride.Name}' of '{DiagnosticUtilities.GetGenericParameterDeclaringMemberDisplayName(new GenericParameterOrigin(genericParameterOverride))}' " +
-                        $"don't match overridden generic parameter '{((GenericParameterDesc)baseProvider).Name}' of '{DiagnosticUtilities.GetGenericParameterDeclaringMemberDisplayName(new GenericParameterOrigin((GenericParameterDesc)baseProvider))}'. " +
-                        $"All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.",
-                        2095, origin, subcategory: MessageSubCategory.TrimAnalysis);
+                    _logger.LogWarning(origin, DiagnosticId.DynamicallyAccessedMembersMismatchOnGenericParameterBetweenOverrides,
+                        genericParameterOverride.Name, DiagnosticUtilities.GetGenericParameterDeclaringMemberDisplayName(new GenericParameterOrigin(genericParameterOverride)),
+                        ((GenericParameterDesc)baseProvider).Name, DiagnosticUtilities.GetGenericParameterDeclaringMemberDisplayName(new GenericParameterOrigin((GenericParameterDesc)baseProvider)));
                     break;
                 case TypeDesc methodReturnType:
-                    _logger.LogWarning(
-                        $"'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the return value of method '{DiagnosticUtilities.GetMethodSignatureDisplayName(origin)}' " +
-                        $"don't match overridden return value of method '{DiagnosticUtilities.GetMethodSignatureDisplayName((MethodDesc)baseProvider)}'. " +
-                        $"All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.",
-                        2093, origin, subcategory: MessageSubCategory.TrimAnalysis);
+                    _logger.LogWarning(origin, DiagnosticId.DynamicallyAccessedMembersMismatchOnMethodReturnValueBetweenOverrides,
+                        DiagnosticUtilities.GetMethodSignatureDisplayName(origin), DiagnosticUtilities.GetMethodSignatureDisplayName((MethodDesc)baseProvider));
                     break;
                 // No fields - it's not possible to have a virtual field and override it
                 case MethodDesc methodDefinition:
-                    _logger.LogWarning(
-                        $"'DynamicallyAccessedMemberTypes' in 'DynamicallyAccessedMembersAttribute' on the implicit 'this' parameter of method '{DiagnosticUtilities.GetMethodSignatureDisplayName(methodDefinition)}' " +
-                        $"don't match overridden implicit 'this' parameter of method '{DiagnosticUtilities.GetMethodSignatureDisplayName((MethodDesc)baseProvider)}'. " +
-                        $"All overridden members must have the same 'DynamicallyAccessedMembersAttribute' usage.",
-                        2094, origin, subcategory: MessageSubCategory.TrimAnalysis);
+                    _logger.LogWarning(origin, DiagnosticId.DynamicallyAccessedMembersMismatchOnImplicitThisBetweenOverrides,
+                        DiagnosticUtilities.GetMethodSignatureDisplayName(methodDefinition), DiagnosticUtilities.GetMethodSignatureDisplayName((MethodDesc)baseProvider));
                     break;
                 default:
                     throw new NotImplementedException($"Unsupported provider type {provider.GetType()}");
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs
index 1f198fbc155e7a..420dc07dcfa759 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMethodBodyScanner.cs
@@ -2226,9 +2226,8 @@ public override bool HandleCall(MethodIL callingMethodBody, MethodDesc calledMet
                         {
                             string arg1 = MessageFormat.FormatRequiresAttributeMessageArg(DiagnosticUtilities.GetRequiresAttributeMessage(calledMethod, "RequiresUnreferencedCodeAttribute"));
                             string arg2 = MessageFormat.FormatRequiresAttributeUrlArg(DiagnosticUtilities.GetRequiresAttributeUrl(calledMethod, "RequiresUnreferencedCodeAttribute"));
-                            string message = new DiagnosticString(DiagnosticId.RequiresUnreferencedCode).GetMessage(calledMethod.GetDisplayName(), arg1, arg2);
 
-                            _logger.LogWarning(message, (int)DiagnosticId.RequiresUnreferencedCode, callingMethodBody, offset, MessageSubCategory.TrimAnalysis);
+                            _logger.LogWarning(callingMethodBody, offset, DiagnosticId.RequiresUnreferencedCode, calledMethod.GetDisplayName(), arg1, arg2);
                         }
 
                         if (shouldEnableAotWarnings &&
@@ -2241,9 +2240,8 @@ static void LogDynamicCodeWarning(Logger logger, MethodIL callingMethodBody, int
                         {
                             string arg1 = MessageFormat.FormatRequiresAttributeMessageArg(DiagnosticUtilities.GetRequiresAttributeMessage(calledMethod, "RequiresDynamicCodeAttribute"));
                             string arg2 = MessageFormat.FormatRequiresAttributeUrlArg(DiagnosticUtilities.GetRequiresAttributeUrl(calledMethod, "RequiresDynamicCodeAttribute"));
-                            string message = new DiagnosticString(DiagnosticId.RequiresDynamicCode).GetMessage(calledMethod.GetDisplayName(), arg1, arg2);
 
-                            logger.LogWarning(message, (int)DiagnosticId.RequiresDynamicCode, callingMethodBody, offset, MessageSubCategory.AotAnalysis);
+                            logger.LogWarning(callingMethodBody, offset, DiagnosticId.RequiresDynamicCode, calledMethod.GetDisplayName(), arg1, arg2);
                         }
 
                         // To get good reporting of errors we need to track the origin of the value for all method calls
@@ -2933,32 +2931,20 @@ void WarnOnReflectionAccess(ref ReflectionPatternContext context, TypeSystemEnti
                 // are not suppressed in RUC scopes. Here the scope represents the DynamicallyAccessedMembers
                 // annotation on a type, not a callsite which uses the annotation. We always want to warn about
                 // possible reflection access indicated by these annotations.
-
-                var message = string.Format(
-                        "'DynamicallyAccessedMembersAttribute' on '{0}' or one of its base types references '{1}' which has 'DynamicallyAccessedMembersAttribute' requirements.",
-                        ((TypeOrigin)context.MemberWithRequirements).GetDisplayName(),
-                        entity.GetDisplayName());
-                _logger.LogWarning(message, 2115, context.Source, MessageSubCategory.TrimAnalysis);
+                _logger.LogWarning(context.Source, DiagnosticId.DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithDynamicallyAccessedMembers,
+                    ((TypeOrigin)context.MemberWithRequirements).GetDisplayName(), entity.GetDisplayName());
             }
             else
             {
                 if (entity is FieldDesc && context.ReportingEnabled)
                 {
-                    _logger.LogWarning(
-                        $"Field '{entity.GetDisplayName()}' with 'DynamicallyAccessedMembersAttribute' is accessed via reflection. Trimmer can't guarantee availability of the requirements of the field.",
-                        2110,
-                        context.Source,
-                        MessageSubCategory.TrimAnalysis);
+                    _logger.LogWarning(context.Source, DiagnosticId.DynamicallyAccessedMembersFieldAccessedViaReflection, entity.GetDisplayName());
                 }
                 else
                 {
                     Debug.Assert(entity is MethodDesc);
 
-                    _logger.LogWarning(
-                    $"Method '{entity.GetDisplayName()}' with parameters or return value with `DynamicallyAccessedMembersAttribute` is accessed via reflection. Trimmer can't guarantee availability of the requirements of the method.",
-                    2111,
-                    context.Source,
-                    MessageSubCategory.TrimAnalysis);
+                    _logger.LogWarning(context.Source, DiagnosticId.DynamicallyAccessedMembersMethodAccessedViaReflection, entity.GetDisplayName());
                 }
             }
         }
@@ -2969,11 +2955,8 @@ void MarkMethod(ref ReflectionPatternContext reflectionContext, MethodDesc metho
             {
                 if (_purpose == ScanningPurpose.GetTypeDataflow)
                 {
-                    var message = string.Format(
-                        "'DynamicallyAccessedMembersAttribute' on '{0}' or one of its base types references '{1}' which requires unreferenced code.",
-                        ((TypeOrigin)reflectionContext.MemberWithRequirements).GetDisplayName(),
-                        method.GetDisplayName());
-                    _logger.LogWarning(message, 2113, reflectionContext.Source, MessageSubCategory.TrimAnalysis);
+                    _logger.LogWarning(reflectionContext.Source, DiagnosticId.DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithRequiresUnreferencedCode,
+                        ((TypeOrigin)reflectionContext.MemberWithRequirements).GetDisplayName(), method.GetDisplayName());
                 }
             }
 
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs
index 07e2768797cabe..cfbfe6d7a5e476 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/LazyGenerics/ModuleCycleInfo.cs
@@ -234,14 +234,9 @@ public void LogWarnings(Logger logger)
                     if (!reportedProblems.Add(new EntityPair(ownerDefinition, referentDefinition)))
                         continue;
 
-                    string message = $"Generic expansion to '{actualProblem.Key.Referent.GetDisplayName()}' was aborted " +
-                        "due to generic recursion. An exception will be thrown at runtime if this codepath is ever reached. " +
-                        "Generic recursion also negatively affects compilation speed and the size of the compilation output. " +
-                        "It is advisable to remove the source of the generic recursion by restructuring the program around " +
-                        "the source of recursion. The source of generic recursion might include: ";
-
                     ModuleCycleInfo cycleInfo = actualProblem.Value;
                     bool first = true;
+                    string message = "";
                     foreach (TypeSystemEntity cycleEntity in cycleInfo.EntitiesInCycles)
                     {
                         if (!first)
@@ -252,7 +247,7 @@ public void LogWarnings(Logger logger)
                         message += $"'{cycleEntity.GetDisplayName()}'";
                     }
 
-                    logger.LogWarning(message, 3054, actualProblem.Key.Owner, MessageSubCategory.AotAnalysis);
+                    logger.LogWarning(actualProblem.Key.Owner, DiagnosticId.GenericRecursionCycle, actualProblem.Key.Referent.GetDisplayName(), message);
                 }
             }
         }
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedInteropStubManager.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedInteropStubManager.cs
index e1c1362e109c02..430c77f98f9056 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedInteropStubManager.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedInteropStubManager.cs
@@ -73,12 +73,7 @@ private void AddParameterMarshallingDependencies(ref DependencyList dependencies
                     reportedMethod = delegateThunkMethod.InvokeMethod;
                 }
 
-                var message = new DiagnosticString(DiagnosticId.CorrectnessOfAbstractDelegatesCannotBeGuaranteed).GetMessage(DiagnosticUtilities.GetMethodSignatureDisplayName(method));
-                _logger.LogWarning(
-                    message,
-                    (int)DiagnosticId.CorrectnessOfAbstractDelegatesCannotBeGuaranteed,
-                    reportedMethod,
-                    MessageSubCategory.AotAnalysis);
+                _logger.LogWarning(reportedMethod, DiagnosticId.CorrectnessOfAbstractDelegatesCannotBeGuaranteed, DiagnosticUtilities.GetMethodSignatureDisplayName(method));
             }
 
             // struct may contain delegate fields, hence we need to add dependencies for it
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs
index 971d932be8c10c..46702412ba73a2 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UsageBasedMetadataManager.cs
@@ -683,16 +683,12 @@ public override void NoteOverridingMethod(MethodDesc baseMethod, MethodDesc over
 
             if (baseMethodRequiresUnreferencedCode != overridingMethodRequiresUnreferencedCode)
             {
-                Logger.LogWarning(
-                    $"Presence of 'RequiresUnreferencedCodeAttribute' on method '{overridingMethod.GetDisplayName()}' doesn't match overridden method '{baseMethod.GetDisplayName()}'. " +
-                    $"All overridden methods must have 'RequiresUnreferencedCodeAttribute'.", 2046, overridingMethod, MessageSubCategory.TrimAnalysis);
+                Logger.LogWarning(overridingMethod, DiagnosticId.RequiresUnreferencedCodeAttributeMismatch, overridingMethod.GetDisplayName(), baseMethod.GetDisplayName());
             }
 
             if (baseMethodRequiresDynamicCode != overridingMethodRequiresDynamicCode)
             {
-                Logger.LogWarning(
-                    $"Presence of 'RequiresDynamicCodeAttribute' on method '{overridingMethod.GetDisplayName()}' doesn't match overridden method '{baseMethod.GetDisplayName()}'. " +
-                    $"All overridden methods must have 'RequiresDynamicCodeAttribute'.", 2046, overridingMethod, MessageSubCategory.AotAnalysis);
+                Logger.LogWarning(overridingMethod, DiagnosticId.RequiresDynamicCodeAttributeMismatch, overridingMethod.GetDisplayName(), baseMethod.GetDisplayName());
             }
 
             if (baseMethodRequiresDataflow || overridingMethodRequiresDataflow)
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs
index 8f468f78b39771..46ed11d236a953 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilationBuilder.cs
@@ -24,7 +24,6 @@ public sealed class ReadyToRunCodegenCompilationBuilder : CompilationBuilder
         private readonly IEnumerable<string> _inputFiles;
         private readonly string _compositeRootPath;
         private bool _ibcTuning;
-        private bool _resilient;
         private bool _generateMapFile;
         private bool _generateMapCsvFile;
         private bool _generatePdbFile;
@@ -117,12 +116,6 @@ public ReadyToRunCodegenCompilationBuilder UseIbcTuning(bool ibcTuning)
             return this;
         }
 
-        public ReadyToRunCodegenCompilationBuilder UseResilience(bool resilient)
-        {
-            _resilient = resilient;
-            return this;
-        }
-
         public ReadyToRunCodegenCompilationBuilder UseProfileData(ProfileDataManager profileData)
         {
             _profileData = profileData;
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
index f05301ce6367e7..7e2b624a3131fc 100644
--- a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
+++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilation.cs
@@ -199,8 +199,6 @@ private void CompileSingleMethod(CorInfoImpl corInfo, MethodCodeNode methodCodeN
 
             if (exception != null)
             {
-                // TODO: fail compilation if a switch was passed
-
                 // Try to compile the method again, but with a throwing method body this time.
                 MethodIL throwingIL = TypeSystemThrowingILEmitter.EmitIL(method, exception);
                 corInfo.CompileMethod(methodCodeNodeNeedingCode, throwingIL);
@@ -209,12 +207,12 @@ private void CompileSingleMethod(CorInfoImpl corInfo, MethodCodeNode methodCodeN
                     && method.OwningType is MetadataType mdOwningType
                     && mdOwningType.HasCustomAttribute("System.Runtime.InteropServices", "ClassInterfaceAttribute"))
                 {
-                    Logger.LogWarning("COM interop is not supported with full ahead of time compilation", 3052, method, MessageSubCategory.AotAnalysis);
+                    Logger.LogWarning(method, DiagnosticId.COMInteropNotSupportedInFullAOT);
                 }
+                if ((_compilationOptions & RyuJitCompilationOptions.UseResilience) != 0)
+                    Logger.LogMessage($"Ignoring unresolved method {method}, because: {exception.Message}");
                 else
-                {
-                    Logger.LogWarning($"Method will always throw because: {exception.Message}", 1005, method, MessageSubCategory.AotAnalysis);
-                }
+                    Logger.LogError($"Method will always throw because: {exception.Message}", 1005, method, MessageSubCategory.AotAnalysis);
             }
         }
 
@@ -247,5 +245,6 @@ public enum RyuJitCompilationOptions
         MethodBodyFolding = 0x1,
         ControlFlowGuardAnnotations = 0x2,
         UseDwarf5 = 0x4,
+        UseResilience = 0x8,
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs
index 628277d75e6f5c..a1446f9d3ff274 100644
--- a/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs
+++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/Compiler/RyuJitCompilationBuilder.cs
@@ -113,6 +113,9 @@ public override ICompilation ToCompilation()
             if (_useDwarf5)
                 options |= RyuJitCompilationOptions.UseDwarf5;
 
+            if (_resilient)
+                options |= RyuJitCompilationOptions.UseResilience;
+
             var factory = new RyuJitNodeFactory(_context, _compilationGroup, _metadataManager, _interopStubManager, _nameMangler, _vtableSliceProvider, _dictionaryLayoutProvider, GetPreinitializationManager());
 
             JitConfigProvider.Initialize(_context.Target, jitFlagBuilder.ToArray(), _ryujitOptions);
diff --git a/src/coreclr/tools/aot/ILCompiler/Program.cs b/src/coreclr/tools/aot/ILCompiler/Program.cs
index 6cfa82c81b2b0b..51400a9e939be0 100644
--- a/src/coreclr/tools/aot/ILCompiler/Program.cs
+++ b/src/coreclr/tools/aot/ILCompiler/Program.cs
@@ -85,6 +85,8 @@ internal class Program
 
         private IReadOnlyList<string> _directPInvokeLists = Array.Empty<string>();
 
+        private bool _resilient;
+
         private IReadOnlyList<string> _rootedAssemblies = Array.Empty<string>();
         private IReadOnlyList<string> _conditionallyRootedAssemblies = Array.Empty<string>();
         private IReadOnlyList<string> _trimmedAssemblies = Array.Empty<string>();
@@ -190,6 +192,7 @@ private ArgumentSyntax ParseCommandLine(string[] args)
                 syntax.DefineOption("systemmodule", ref _systemModuleName, "System module name (default: System.Private.CoreLib)");
                 syntax.DefineOption("multifile", ref _multiFile, "Compile only input files (do not compile referenced assemblies)");
                 syntax.DefineOption("waitfordebugger", ref waitForDebugger, "Pause to give opportunity to attach debugger");
+                syntax.DefineOption("resilient", ref _resilient, "Ignore unresolved types, methods, and assemblies. Defaults to false");
                 syntax.DefineOptionList("codegenopt", ref _codegenOptions, "Define a codegen option");
                 syntax.DefineOptionList("rdxml", ref _rdXmlFilePaths, "RD.XML file(s) for compilation");
                 syntax.DefineOption("map", ref _mapFileName, "Generate a map file");
@@ -801,6 +804,8 @@ static string ILLinkify(string rootedAssembly)
                 builder.UseMethodImportationErrorProvider(scanResults.GetMethodImportationErrorProvider());
             }
 
+            builder.UseResilience(_resilient);
+
             ICompilation compilation = builder.ToCompilation();
 
             ObjectDumper dumper = _mapFileName != null ? new ObjectDumper(_mapFileName) : null;
diff --git a/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs b/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs
index e25b16f8ef8447..5ec2e6ec7c5541 100644
--- a/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs
+++ b/src/coreclr/tools/aot/ILLink.Shared/DiagnosticId.cs
@@ -77,7 +77,7 @@ public enum DiagnosticId
         _unused_RearrangedXmlWarning2 = 2021,
         XmlCouldNotFindMatchingConstructorForCustomAttribute = 2022,
         XmlMoreThanOneReturnElementForMethod = 2023,
-        XmlMoreThanOneValyForParameterOfMethod = 2024,
+        XmlMoreThanOneValueForParameterOfMethod = 2024,
         XmlDuplicatePreserveMember = 2025,
         RequiresUnreferencedCode = 2026,
         AttributeShouldOnlyBeUsedOnceOnMember = 2027,
@@ -183,10 +183,9 @@ public enum DiagnosticId
         // Dynamic code diagnostic ids.
         RequiresDynamicCode = 3050,
         RequiresDynamicCodeAttributeMismatch = 3051,
-        // TODO: these are all unique to NativeAOT - mono/linker repo is not aware these error codes usage.
-        // IL3052 - COM
-        // IL3053 - AOT analysis warnings
-        // IL3054 - Generic cycle
+        COMInteropNotSupportedInFullAOT = 3052,
+        AssemblyProducedAOTWarnings = 3053,
+        GenericRecursionCycle = 3054,
         CorrectnessOfAbstractDelegatesCannotBeGuaranteed = 3055,
     }
 
@@ -205,11 +204,13 @@ public static string GetDiagnosticSubcategory(this DiagnosticId diagnosticId) =>
                 2045 => MessageSubCategory.TrimAnalysis,
                 2046 => MessageSubCategory.TrimAnalysis,
                 2050 => MessageSubCategory.TrimAnalysis,
-                var x when x >= 2055 && x <= 2099 => MessageSubCategory.TrimAnalysis,
+                >= 2055 and <= 2099 => MessageSubCategory.TrimAnalysis,
                 2103 => MessageSubCategory.TrimAnalysis,
                 2106 => MessageSubCategory.TrimAnalysis,
                 2107 => MessageSubCategory.TrimAnalysis,
-                var x when x >= 2109 && x <= 2116 => MessageSubCategory.TrimAnalysis,
+                >= 2109 and <= 2116 => MessageSubCategory.TrimAnalysis,
+                >= 3050 and <= 3052 => MessageSubCategory.AotAnalysis,
+                >= 3054 and <= 3055 => MessageSubCategory.AotAnalysis,
                 _ => MessageSubCategory.None,
             };
     }
diff --git a/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx b/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx
index e2db35e7073313..fe39e38906517a 100644
--- a/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx
+++ b/src/coreclr/tools/aot/ILLink.Shared/SharedStrings.resx
@@ -524,10 +524,10 @@
   <data name="XmlMoreThanOneReturnElementForMethodMessage" xml:space="preserve">
     <value>There is more than one 'return' child element specified for method '{0}'.</value>
   </data>
-  <data name="XmlMoreThanOneValyForParameterOfMethodTitle" xml:space="preserve">
+  <data name="XmlMoreThanOneValueForParameterOfMethodTitle" xml:space="preserve">
     <value>Method has more than one parameter for the XML element 'parameter'. There can only be one value specified for each parameter.</value>
   </data>
-  <data name="XmlMoreThanOneValyForParameterOfMethodMessage" xml:space="preserve">
+  <data name="XmlMoreThanOneValueForParameterOfMethodMessage" xml:space="preserve">
     <value>More than one value specified for parameter '{0}' of method '{1}'.</value>
   </data>
   <data name="XmlDuplicatePreserveMemberTitle" xml:space="preserve">
@@ -1100,6 +1100,30 @@
   <data name="RequiresDynamicCodeAttributeMismatchMessage" xml:space="preserve">
     <value>{0}. 'RequiresDynamicCodeAttribute' annotations must match across all interface implementations or overrides.</value>
   </data>
+  <data name="COMInteropNotSupportedInFullAOTTitle" xml:space="preserve">
+    <value>COM interop is not supported with full ahead of time compilation.</value>
+  </data>
+  <data name="COMInteropNotSupportedInFullAOTMessage" xml:space="preserve">
+    <value>COM interop is not supported with full ahead of time compilation.</value>
+  </data>
+  <data name="AssemblyProducedAOTWarningsTitle" xml:space="preserve">
+    <value>Assembly produced AOT analysis warnings.</value>
+  </data>
+  <data name="AssemblyProducedAOTWarningsMessage" xml:space="preserve">
+    <value>Assembly '{0}' produced AOT analysis warnings.</value>
+  </data>
+  <data name="GenericRecursionCycleTitle" xml:space="preserve">
+    <value>Generic expansion to was aborted due to generic recursion. An exception will be thrown at runtime if this codepath is ever reached.</value>
+  </data>
+  <data name="GenericRecursionCycleMessage" xml:space="preserve">
+    <value>Generic expansion to '{0}' was aborted due to generic recursion. An exception will be thrown at runtime if this codepath is ever reached. Generic recursion also negatively affects compilation speed and the size of the compilation output. It is advisable to remove the source of the generic recursion by restructuring the program around the source of recursion. The source of generic recursion might include: {1}</value>
+  </data>
+  <data name="CorrectnessOfAbstractDelegatesCannotBeGuaranteedTitle" xml:space="preserve">
+    <value>P/invoke method declares a parameter with an abstract delegate. Correctness of interop for abstract delegates cannot be guaranteed after native compilation.</value>
+  </data>
+  <data name="CorrectnessOfAbstractDelegatesCannotBeGuaranteedMessage" xml:space="preserve">
+    <value>P/invoke method '{0}' declares a parameter with an abstract delegate. Correctness of interop for abstract delegates cannot be guaranteed after native compilation: the marshalling code for the delegate might not be available. Use a non-abstract delegate type or ensure any delegate instance passed as parameter is marked with `UnmanagedFunctionPointerAttribute`.</value>
+  </data>
   <data name="BaseRequiresMismatchMessage" xml:space="preserve">
     <value>Base member '{2}' with '{0}' has a derived member '{1}' without '{0}'</value>
   </data>
@@ -1112,10 +1136,4 @@
   <data name="InterfaceRequiresMismatchMessage" xml:space="preserve">
     <value>Interface member '{2}' with '{0}' has an implementation member '{1}' without '{0}'</value>
   </data>
-  <data name="CorrectnessOfAbstractDelegatesCannotBeGuaranteedTitle" xml:space="preserve">
-    <value>P/invoke method declares a parameter with an abstract delegate. Correctness of interop for abstract delegates cannot be guaranteed after native compilation.</value>
-  </data>
-  <data name="CorrectnessOfAbstractDelegatesCannotBeGuaranteedMessage" xml:space="preserve">
-    <value>P/invoke method '{0}' declares a parameter with an abstract delegate. Correctness of interop for abstract delegates cannot be guaranteed after native compilation: the marshalling code for the delegate might not be available. Use a non-abstract delegate type or ensure any delegate instance passed as parameter is marked with `UnmanagedFunctionPointerAttribute`.</value>
-  </data>
 </root>
diff --git a/src/coreclr/tools/aot/crossgen2/Program.cs b/src/coreclr/tools/aot/crossgen2/Program.cs
index ff538c05fd64c4..6eedd33da4a6d0 100644
--- a/src/coreclr/tools/aot/crossgen2/Program.cs
+++ b/src/coreclr/tools/aot/crossgen2/Program.cs
@@ -730,7 +730,6 @@ private void RunSingleCompilation(Dictionary<string, string> inFilePaths, Instru
 
                     builder
                         .UseIbcTuning(_commandLineOptions.Tuning)
-                        .UseResilience(_commandLineOptions.Resilient)
                         .UseMapFile(_commandLineOptions.Map)
                         .UseMapCsvFile(_commandLineOptions.MapCsv)
                         .UsePdbFile(_commandLineOptions.Pdb, _commandLineOptions.PdbPath)
@@ -748,6 +747,7 @@ private void RunSingleCompilation(Dictionary<string, string> inFilePaths, Instru
                         .UseBackendOptions(_commandLineOptions.CodegenOptions)
                         .UseLogger(logger)
                         .UseParallelism(_commandLineOptions.Parallelism)
+                        .UseResilience(_commandLineOptions.Resilient)
                         .UseDependencyTracking(trackingLevel)
                         .UseCompilationRoots(compilationRoots)
                         .UseOptimizationMode(optimizationMode);

From 9ae484f9e5e6b952c1ec9a95a21ffbc8153139b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladimir=20Djuri=C4=87?= <vladimir@djuric.si>
Date: Thu, 27 Jan 2022 10:14:19 +0100
Subject: [PATCH 104/161] Trying to fix issue #63788:
 "NetworkChange.NetworkAddressChanged event leaks threads on Linux (#63963)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Trying to fix issue #63788: "NetworkChange.NetworkAddressChanged event leaks threads on Linux"

* Adding socket receive timeout to native method + functional test

* Update src/native/libs/System.Native/pal_networkchange.c

ManickaP replaced tabs with spaces

Co-authored-by: Marie Píchová <11718369+ManickaP@users.noreply.github.com>

* Using setsockopt after socket was successfully set, checking setsockopt result.

* Adding support for conditional network address changed functional test

* Adding support for conditional network address changed functional test

* Using reference checking method to determine if socket is changed as suggested by user @tmds

* Test method update

* Test method update due to some failing tests

* Removing yield return from test

* Reverting back to yield and adding ToArray() when testing if ps is available

* Socket wrapper is now nullable

* Update src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/NetworkAddressChangedTests.cs

Co-authored-by: vdjuric <vladimir@LEGION21.localdomain>
Co-authored-by: Marie Píchová <11718369+ManickaP@users.noreply.github.com>
---
 .../NetworkAddressChange.Unix.cs              | 53 +++++++++-----
 .../NetworkAddressChangedTests.cs             | 29 ++++++++
 .../tests/FunctionalTests/ProcessUtil.cs      | 72 +++++++++++++++++++
 ...NetworkInformation.Functional.Tests.csproj |  2 +
 .../FunctionalTests/TestConfiguration.cs      | 29 ++++++++
 .../libs/System.Native/pal_networkchange.c    | 15 ++++
 6 files changed, 181 insertions(+), 19 deletions(-)
 create mode 100644 src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/ProcessUtil.cs
 create mode 100644 src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/TestConfiguration.cs

diff --git a/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/NetworkAddressChange.Unix.cs b/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/NetworkAddressChange.Unix.cs
index 5d95e8b2b9733d..30bd2f7713d842 100644
--- a/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/NetworkAddressChange.Unix.cs
+++ b/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/NetworkAddressChange.Unix.cs
@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Threading.Tasks;
 using System.Threading;
 
 namespace System.Net.NetworkInformation
@@ -12,7 +11,7 @@ namespace System.Net.NetworkInformation
     // Linux implementation of NetworkChange
     public partial class NetworkChange
     {
-        private static volatile int s_socket;
+        private static volatile SocketWrapper? s_socket;
         // Lock controlling access to delegate subscriptions, socket initialization, availability-changed state and timer.
         private static readonly object s_gate = new object();
 
@@ -34,7 +33,7 @@ public static event NetworkAddressChangedEventHandler? NetworkAddressChanged
                 {
                     lock (s_gate)
                     {
-                        if (s_socket == 0)
+                        if (s_socket == null)
                         {
                             CreateSocket();
                         }
@@ -51,8 +50,8 @@ public static event NetworkAddressChangedEventHandler? NetworkAddressChanged
                     {
                         if (s_addressChangedSubscribers.Count == 0 && s_availabilityChangedSubscribers.Count == 0)
                         {
-                            Debug.Assert(s_socket == 0,
-                                "s_socket != 0, but there are no subscribers to NetworkAddressChanged or NetworkAvailabilityChanged.");
+                            Debug.Assert(s_socket == null,
+                                "s_socket is not null, but there are no subscribers to NetworkAddressChanged or NetworkAvailabilityChanged.");
                             return;
                         }
 
@@ -74,7 +73,7 @@ public static event NetworkAvailabilityChangedEventHandler? NetworkAvailabilityC
                 {
                     lock (s_gate)
                     {
-                        if (s_socket == 0)
+                        if (s_socket == null)
                         {
                             CreateSocket();
                         }
@@ -113,8 +112,8 @@ public static event NetworkAvailabilityChangedEventHandler? NetworkAvailabilityC
                     {
                         if (s_addressChangedSubscribers.Count == 0 && s_availabilityChangedSubscribers.Count == 0)
                         {
-                            Debug.Assert(s_socket == 0,
-                                "s_socket != 0, but there are no subscribers to NetworkAddressChanged or NetworkAvailabilityChanged.");
+                            Debug.Assert(s_socket == null,
+                                "s_socket is not null, but there are no subscribers to NetworkAddressChanged or NetworkAvailabilityChanged.");
                             return;
                         }
 
@@ -140,7 +139,7 @@ public static event NetworkAvailabilityChangedEventHandler? NetworkAvailabilityC
 
         private static unsafe void CreateSocket()
         {
-            Debug.Assert(s_socket == 0, "s_socket != 0, must close existing socket before opening another.");
+            Debug.Assert(s_socket == null, "s_socket is not null, must close existing socket before opening another.");
             int newSocket;
             Interop.Error result = Interop.Sys.CreateNetworkChangeListenerSocket(&newSocket);
             if (result != Interop.Error.SUCCESS)
@@ -149,32 +148,34 @@ private static unsafe void CreateSocket()
                 throw new NetworkInformationException(message);
             }
 
-            s_socket = newSocket;
-            new Thread(s => LoopReadSocket((int)s!))
+            s_socket = new SocketWrapper(newSocket);
+
+            new Thread(args => LoopReadSocket((SocketWrapper)args!))
             {
                 IsBackground = true,
                 Name = ".NET Network Address Change"
-            }.UnsafeStart(newSocket);
+            }.UnsafeStart(s_socket);
         }
 
         private static void CloseSocket()
         {
-            Debug.Assert(s_socket != 0, "s_socket was 0 when CloseSocket was called.");
-            Interop.Error result = Interop.Sys.CloseNetworkChangeListenerSocket(s_socket);
+            Debug.Assert(s_socket != null, "s_socket was null when CloseSocket was called.");
+            Interop.Error result = Interop.Sys.CloseNetworkChangeListenerSocket(s_socket != null ? s_socket.Socket : -1);
             if (result != Interop.Error.SUCCESS)
             {
                 string message = Interop.Sys.GetLastErrorInfo().GetErrorMessage();
                 throw new NetworkInformationException(message);
             }
 
-            s_socket = 0;
+            s_socket = null;
         }
 
-        private static unsafe void LoopReadSocket(int socket)
+        private static unsafe void LoopReadSocket(SocketWrapper initiallyCreatedSocket)
         {
-            while (socket == s_socket)
+            while (s_socket == initiallyCreatedSocket) //if both references are equal then s_socket was not changed
             {
-                Interop.Sys.ReadEvents(socket, &ProcessEvent);
+                //we can continue processing events
+                Interop.Sys.ReadEvents(initiallyCreatedSocket.Socket, &ProcessEvent);
             }
         }
 
@@ -185,7 +186,7 @@ private static void ProcessEvent(int socket, Interop.Sys.NetworkChangeKind kind)
             {
                 lock (s_gate)
                 {
-                    if (socket == s_socket)
+                    if (s_socket != null && socket == s_socket.Socket)
                     {
                         OnSocketEvent(kind);
                     }
@@ -290,5 +291,19 @@ private static void OnAvailabilityTimerFired(object? state)
                 }
             }
         }
+
+        // SocketWrapper class was introduced to prevent event thread leaks on Linux
+        // as described on GitHub: https://github.com/dotnet/runtime/issues/63788
+        // For each CreateSocket() new s_socket instance is created and we pass it to ".NET Network Address Change" thread.
+        // We then continue loop in LoopReadSocket method as long as both references are equal.
+        private class SocketWrapper
+        {
+            public SocketWrapper(int socket)
+            {
+                Socket = socket;
+            }
+
+            public int Socket { get; }
+        }
     }
 }
diff --git a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/NetworkAddressChangedTests.cs b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/NetworkAddressChangedTests.cs
index 6a2a07a81fa0a8..c99f15dcfd4753 100644
--- a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/NetworkAddressChangedTests.cs
+++ b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/NetworkAddressChangedTests.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Xunit;
+using System.Diagnostics;
+using System.Threading;
+using System.Linq;
 
 namespace System.Net.NetworkInformation.Tests
 {
@@ -23,5 +26,31 @@ public void NetworkAddressChanged_JustRemove_Success()
         {
             NetworkChange.NetworkAddressChanged -= _addressHandler;
         }
+
+        [PlatformSpecific(TestPlatforms.Linux)]
+        [OuterLoop("May take several seconds")]
+        [ConditionalFact(nameof(SupportsGettingThreadsWithPsCommand))]
+        public void NetworkAddressChanged_AddRemoveMultipleTimes_CheckForLeakingThreads()
+        {
+            for (int i = 1; i <= 10; i++)
+            {
+                NetworkChange.NetworkAddressChanged += _addressHandler;
+                NetworkChange.NetworkAddressChanged -= _addressHandler;
+            }
+
+            Thread.Sleep(2000); //allow some time for threads to exit
+
+            //We are searching for threads containing ".NET Network Ad"
+            //because ps command trims actual thread name ".NET Network Address Change".
+            //This thread is created in:
+            //  src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/NetworkAddressChange.Unix.cs
+            int numberOfNetworkAddressChangeThreads = ProcessUtil.GetProcessThreadsWithPsCommand(Process.GetCurrentProcess().Id)
+                .Where(e => e.IndexOf(".NET Network Ad") > 0).Count();
+
+            Assert.Equal(0, numberOfNetworkAddressChangeThreads); //there should be no threads because there are no event subscribers
+        }
+
+        private static bool SupportsGettingThreadsWithPsCommand
+            => TestConfiguration.SupportsGettingThreadsWithPsCommand;
     }
 }
diff --git a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/ProcessUtil.cs b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/ProcessUtil.cs
new file mode 100644
index 00000000000000..842c20672ce702
--- /dev/null
+++ b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/ProcessUtil.cs
@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace System.Net.NetworkInformation.Tests
+{
+    internal static class ProcessUtil
+    {
+        public static IEnumerable<string> GetProcessThreadsWithPsCommand(int pid, int? timeoutInMilliseconds = null)
+        {
+            ProcessStartInfo psi = new ProcessStartInfo("ps", $"-T --no-headers -p {pid}");
+            psi.RedirectStandardOutput = true;
+
+            Process? process;
+
+            try
+            {
+                process = Process.Start(psi);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Exception while trying to run 'ps' command", ex);
+            }
+
+            if (process == null)
+            {
+                throw new Exception("Could not create process 'ps'");
+            }
+
+            try
+            {
+                if (timeoutInMilliseconds.HasValue)
+                {
+                    if (!process.WaitForExit(timeoutInMilliseconds.Value))
+                    {
+                        throw new Exception($"Process 'ps' did not exit after {timeoutInMilliseconds} milliseconds");
+                    }
+                }
+                else
+                {
+                    process.WaitForExit();
+                }
+
+                string output = process.StandardOutput.ReadToEnd();
+                if (process.ExitCode != 0)
+                {
+                    throw new Exception($"Process 'ps' returned exit code {process.ExitCode}");
+                }
+
+                using StringReader sr = new StringReader(output);
+
+                while (true)
+                {
+                    string? line = sr.ReadLine();
+                    if (line == null)
+                    {
+                        break;
+                    }
+
+                    yield return line;
+                }
+            }
+            finally
+            {
+                process.Dispose();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj
index 911dc187186c32..efd19ba3094f1f 100644
--- a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj
+++ b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj
@@ -40,6 +40,8 @@
     <Compile Include="PhysicalAddressTest.cs" />
     <Compile Include="ConnectionsParsingTests.cs" />
     <Compile Include="StatisticsParsingTests.cs" />
+    <Compile Include="ProcessUtil.cs" />
+    <Compile Include="TestConfiguration.cs" />
     <!-- Common test files -->
     <Compile Include="$(CommonTestPath)System\Net\Http\TestHelper.cs"
              Link="Common\System\Net\Http\TestHelper.cs" />
diff --git a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/TestConfiguration.cs b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/TestConfiguration.cs
new file mode 100644
index 00000000000000..058f13d49d7009
--- /dev/null
+++ b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/TestConfiguration.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Linq;
+
+namespace System.Net.NetworkInformation.Tests
+{
+    internal static class TestConfiguration
+    {
+        public static bool SupportsGettingThreadsWithPsCommand { get { return s_supportsGettingThreadsWithPsCommand.Value; } }
+
+        private static Lazy<bool> s_supportsGettingThreadsWithPsCommand = new Lazy<bool>(() =>
+        {
+            if (OperatingSystem.IsWindows())
+            {
+                return false;
+            }
+
+            // On other platforms we will try it.
+            try
+            {
+                _ = ProcessUtil.GetProcessThreadsWithPsCommand(Process.GetCurrentProcess().Id).ToArray();
+                return true;
+            }
+            catch { return false; }
+        });
+    }
+}
\ No newline at end of file
diff --git a/src/native/libs/System.Native/pal_networkchange.c b/src/native/libs/System.Native/pal_networkchange.c
index 725dfe677b952e..b3b39ad3aaa832 100644
--- a/src/native/libs/System.Native/pal_networkchange.c
+++ b/src/native/libs/System.Native/pal_networkchange.c
@@ -35,6 +35,7 @@ Error SystemNative_CreateNetworkChangeListenerSocket(int32_t* retSocket)
     sa.nl_family = AF_NETLINK;
     sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE | RTMGRP_IPV6_ROUTE;
     int32_t sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+
 #elif HAVE_RT_MSGHDR
     int32_t sock = socket(PF_ROUTE, SOCK_RAW, 0);
 #endif
@@ -44,6 +45,20 @@ Error SystemNative_CreateNetworkChangeListenerSocket(int32_t* retSocket)
         return (Error)(SystemNative_ConvertErrorPlatformToPal(errno));
     }
 
+    // Added receive timeout to prevent recvmsg method in SystemNative_ReadEvents to block thread indefinitely.
+    // This allows method SystemNative_ReadEvents to periodically exit and allows .NET thread to exit if needed.
+    struct timeval tv;
+    tv.tv_sec = 1; //we will wait in SystemNative_ReadEvents method for max one second (TODO: is this good default value?)
+    tv.tv_usec = 0;
+
+    if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv) != 0)
+    {
+        *retSocket = -1;
+        Error palError = (Error)(SystemNative_ConvertErrorPlatformToPal(errno));
+        close(sock);
+        return palError;
+    }
+
 #if HAVE_LINUX_RTNETLINK_H
     if (bind(sock, (struct sockaddr*)(&sa), sizeof(sa)) != 0)
     {

From 19291ccf33f1ca130c08eebd3f1cabbee751cd7c Mon Sep 17 00:00:00 2001
From: Egor Bogatov <egorbo@gmail.com>
Date: Thu, 27 Jan 2022 13:57:09 +0300
Subject: [PATCH 105/161] Vector256.IsHardwareAccelerated to return true only
 on AVX2 (#64345)

---
 src/coreclr/jit/hwintrinsic.cpp               | 21 ++++++++++++++++++-
 .../src/System/SpanHelpers.Byte.cs            |  4 ++--
 .../src/System/SpanHelpers.Char.cs            |  4 ++--
 .../JitBlue/Runtime_34587/Runtime_34587.cs    |  2 +-
 4 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/coreclr/jit/hwintrinsic.cpp b/src/coreclr/jit/hwintrinsic.cpp
index 0a5559dfd4122c..fe9729ee7a9f15 100644
--- a/src/coreclr/jit/hwintrinsic.cpp
+++ b/src/coreclr/jit/hwintrinsic.cpp
@@ -285,7 +285,26 @@ NamedIntrinsic HWIntrinsicInfo::lookupId(Compiler*         comp,
 
     bool isIsaSupported = comp->compSupportsHWIntrinsic(isa);
 
-    if ((strcmp(methodName, "get_IsSupported") == 0) || (strcmp(methodName, "get_IsHardwareAccelerated") == 0))
+    bool isHardwareAcceleratedProp = (strcmp(methodName, "get_IsHardwareAccelerated") == 0);
+#ifdef TARGET_XARCH
+    if (isHardwareAcceleratedProp)
+    {
+        // Special case: Some of Vector128/256 APIs are hardware accelerated with Sse1 and Avx1,
+        // but we want IsHardwareAccelerated to return true only when all of them are (there are
+        // still can be cases where e.g. Sse41 might give an additional boost for Vector128, but it's
+        // not important enough to bump the minimal Sse version here)
+        if (strcmp(className, "Vector128") == 0)
+        {
+            isa = InstructionSet_SSE2;
+        }
+        else if (strcmp(className, "Vector256") == 0)
+        {
+            isa = InstructionSet_AVX2;
+        }
+    }
+#endif
+
+    if ((strcmp(methodName, "get_IsSupported") == 0) || isHardwareAcceleratedProp)
     {
         return isIsaSupported ? (comp->compExactlyDependsOn(isa) ? NI_IsSupported_True : NI_IsSupported_Dynamic)
                               : NI_IsSupported_False;
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs
index 3a3bc586912ae8..ddab1018c7ad41 100644
--- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Byte.cs
@@ -64,7 +64,7 @@ ref Unsafe.Add(ref searchSpace, offset + 1),
             // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
             // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
         SEARCH_TWO_BYTES:
-            if (Avx2.IsSupported && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0)
+            if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0)
             {
                 // Find the last unique (which is not equal to ch1) byte
                 // the algorithm is fine if both are equal, just a little bit less efficient
@@ -212,7 +212,7 @@ ref Unsafe.Add(ref searchSpace, relativeIndex + 1),
         // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
         // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
         SEARCH_TWO_BYTES:
-            if (Avx2.IsSupported && searchSpaceMinusValueTailLength >= Vector256<byte>.Count)
+            if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector256<byte>.Count)
             {
                 offset = searchSpaceMinusValueTailLength - Vector256<byte>.Count;
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs
index fb00b062538f2f..c8331dc1523361 100644
--- a/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.Char.cs
@@ -70,7 +70,7 @@ ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + 1)),
             // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
             // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
         SEARCH_TWO_CHARS:
-            if (Avx2.IsSupported && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0)
+            if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<ushort>.Count >= 0)
             {
                 // Find the last unique (which is not equal to ch1) character
                 // the algorithm is fine if both are equal, just a little bit less efficient
@@ -231,7 +231,7 @@ ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, relativeIndex + 1)),
             // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
             // Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
         SEARCH_TWO_CHARS:
-            if (Avx2.IsSupported && searchSpaceMinusValueTailLength >= Vector256<ushort>.Count)
+            if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector256<ushort>.Count)
             {
                 offset = searchSpaceMinusValueTailLength - Vector256<ushort>.Count;
 
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.cs b/src/tests/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.cs
index 543e6b58041586..656da5bdb1aaf6 100644
--- a/src/tests/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.cs
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_34587/Runtime_34587.cs
@@ -664,7 +664,7 @@ static bool ValidateVector256()
         {
             bool succeeded = true;
 
-            if (Avx.IsSupported)
+            if (Avx2.IsSupported)
             {
                 succeeded &= Vector256.IsHardwareAccelerated;
                 succeeded &= Vector256<byte>.Count == 32;

From bab1a209c8d7e317dd2a7e2f5ff02f3bcd3d7d4f Mon Sep 17 00:00:00 2001
From: Bradley Grainger <bgrainger@gmail.com>
Date: Thu, 27 Jan 2022 05:01:32 -0800
Subject: [PATCH 106/161] Override all `Read` methods in `NullTextReader` and
 `NullStreamReader` (#64301)

---
 .../tests/Stream/Stream.NullTests.cs          | 64 ++++++++++++++++---
 .../src/System/IO/StreamReader.cs             | 61 ++++++++++--------
 .../src/System/IO/TextReader.cs               | 18 +-----
 3 files changed, 94 insertions(+), 49 deletions(-)

diff --git a/src/libraries/System.IO/tests/Stream/Stream.NullTests.cs b/src/libraries/System.IO/tests/Stream/Stream.NullTests.cs
index 5b2ab1f81e8789..efe700c1e9c753 100644
--- a/src/libraries/System.IO/tests/Stream/Stream.NullTests.cs
+++ b/src/libraries/System.IO/tests/Stream/Stream.NullTests.cs
@@ -123,6 +123,16 @@ public static void TestNullStream_WriteByte()
             Assert.Equal(0, source.Position);
         }
 
+        [Theory]
+        [MemberData(nameof(NullReaders))]
+        public static void TestNullTextReaderDispose(TextReader input)
+        {
+            // dispose should be a no-op
+            input.Dispose();
+            input.Dispose();
+            Assert.Equal("", input.ReadToEnd());
+        }
+
         [Theory]
         [MemberData(nameof(NullReaders))]
         public static void TestNullTextReader(TextReader input)
@@ -131,16 +141,54 @@ public static void TestNullTextReader(TextReader input)
 
             if (sr != null)
                 Assert.True(sr.EndOfStream, "EndOfStream property didn't return true");
-            input.ReadLine();
-            input.Dispose();
-
-            input.ReadLine();
+            Assert.Null(input.ReadLine());
             if (sr != null)
                 Assert.True(sr.EndOfStream, "EndOfStream property didn't return true");
-            input.Read();
-            input.Peek();
-            input.Read(new char[2], 0, 2);
-            input.ReadToEnd();
+
+            Assert.Equal(-1, input.Read());
+            Assert.Equal(-1, input.Peek());
+            var chars = new char[2];
+            Assert.Equal(0, input.Read(chars, 0, chars.Length));
+            Assert.Equal(0, input.Read(chars.AsSpan()));
+            Assert.Equal(0, input.ReadBlock(chars, 0, chars.Length));
+            Assert.Equal(0, input.ReadBlock(chars.AsSpan()));
+            Assert.Equal("", input.ReadToEnd());
+            input.Dispose();
+        }
+
+        [Theory]
+        [MemberData(nameof(NullReaders))]
+        public static async Task TestNullTextReaderAsync(TextReader input)
+        {
+            var chars = new char[2];
+            Assert.Equal(0, await input.ReadAsync(chars, 0, chars.Length));
+            Assert.Equal(0, await input.ReadAsync(chars.AsMemory(), default));
+            Assert.Equal(0, await input.ReadBlockAsync(chars, 0, chars.Length));
+            Assert.Equal(0, await input.ReadBlockAsync(chars.AsMemory(), default));
+            Assert.Null(await input.ReadLineAsync());
+            Assert.Null(await input.ReadLineAsync(default));
+            Assert.Equal("", await input.ReadToEndAsync());
+            Assert.Equal("", await input.ReadToEndAsync(default));
+            input.Dispose();
+        }
+
+        [Theory]
+        [MemberData(nameof(NullReaders))]
+        public static async Task TestCanceledNullTextReaderAsync(TextReader input)
+        {
+            using CancellationTokenSource tokenSource = new CancellationTokenSource();
+            tokenSource.Cancel();
+            var token = tokenSource.Token;
+            var chars = new char[2];
+            OperationCanceledException ex;
+            ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await input.ReadAsync(chars.AsMemory(), token));
+            Assert.Equal(token, ex.CancellationToken);
+            ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await input.ReadBlockAsync(chars.AsMemory(), token));
+            Assert.Equal(token, ex.CancellationToken);
+            ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await input.ReadLineAsync(token));
+            Assert.Equal(token, ex.CancellationToken);
+            ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await input.ReadToEndAsync(token));
+            Assert.Equal(token, ex.CancellationToken);
             input.Dispose();
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs b/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
index b5aca3d1dfbcf7..b18aff879a87e6 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
@@ -1386,7 +1386,7 @@ private void ThrowIfDisposed()
 
         // No data, class doesn't need to be serializable.
         // Note this class is threadsafe.
-        private sealed class NullStreamReader : StreamReader
+        internal sealed class NullStreamReader : StreamReader
         {
             public override Encoding CurrentEncoding => Encoding.Unicode;
 
@@ -1395,35 +1395,46 @@ protected override void Dispose(bool disposing)
                 // Do nothing - this is essentially unclosable.
             }
 
-            public override int Peek()
-            {
-                return -1;
-            }
+            public override int Peek() => -1;
 
-            public override int Read()
-            {
-                return -1;
-            }
+            public override int Read() => -1;
 
-            public override int Read(char[] buffer, int index, int count)
-            {
-                return 0;
-            }
+            public override int Read(char[] buffer, int index, int count) => 0;
 
-            public override string? ReadLine()
-            {
-                return null;
-            }
+            public override int Read(Span<char> buffer) => 0;
 
-            public override string ReadToEnd()
-            {
-                return string.Empty;
-            }
+            public override Task<int> ReadAsync(char[] buffer, int index, int count) => Task.FromResult(0);
 
-            internal override int ReadBuffer()
-            {
-                return 0;
-            }
+            public override ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken) =>
+                cancellationToken.IsCancellationRequested ? ValueTask.FromCanceled<int>(cancellationToken) : default;
+
+            public override int ReadBlock(char[] buffer, int index, int count) => 0;
+
+            public override int ReadBlock(Span<char> buffer) => 0;
+
+            public override Task<int> ReadBlockAsync(char[] buffer, int index, int count) => Task.FromResult(0);
+
+            public override ValueTask<int> ReadBlockAsync(Memory<char> buffer, CancellationToken cancellationToken) =>
+                cancellationToken.IsCancellationRequested ? ValueTask.FromCanceled<int>(cancellationToken) : default;
+
+            public override string? ReadLine() => null;
+
+            public override Task<string?> ReadLineAsync() => Task.FromResult<string?>(null);
+
+            public override ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken) =>
+                cancellationToken.IsCancellationRequested ? ValueTask.FromCanceled<string?>(cancellationToken) : default;
+
+            public override string ReadToEnd() => "";
+
+            public override Task<string> ReadToEndAsync() => Task.FromResult("");
+
+            public override Task<string> ReadToEndAsync(CancellationToken cancellationToken) =>
+                cancellationToken.IsCancellationRequested ? Task.FromCanceled<string>(cancellationToken) : Task.FromResult("");
+
+            internal override ValueTask<int> ReadAsyncInternal(Memory<char> buffer, CancellationToken cancellationToken) =>
+                cancellationToken.IsCancellationRequested ? ValueTask.FromCanceled<int>(cancellationToken) : default;
+
+            internal override int ReadBuffer() => 0;
         }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs b/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs
index 583fb3c2652ae6..a0536bd022e8ee 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/TextReader.cs
@@ -19,7 +19,8 @@ namespace System.IO
     // There are methods on the Stream class for reading bytes.
     public abstract partial class TextReader : MarshalByRefObject, IDisposable
     {
-        public static readonly TextReader Null = new NullTextReader();
+        // Create our own instance to avoid static field initialization order problems on Mono.
+        public static readonly TextReader Null = new StreamReader.NullStreamReader();
 
         protected TextReader() { }
 
@@ -338,21 +339,6 @@ internal async ValueTask<int> ReadBlockAsyncInternal(Memory<char> buffer, Cancel
         }
         #endregion
 
-        private sealed class NullTextReader : TextReader
-        {
-            public NullTextReader() { }
-
-            public override int Read(char[] buffer, int index, int count)
-            {
-                return 0;
-            }
-
-            public override string? ReadLine()
-            {
-                return null;
-            }
-        }
-
         public static TextReader Synchronized(TextReader reader)
         {
             if (reader == null)

From 9fafc047a5b466f58bf0b9302825f52942f45d7d Mon Sep 17 00:00:00 2001
From: Meri Khamoyan <96171496+mkhamoyan@users.noreply.github.com>
Date: Thu, 27 Jan 2022 17:23:09 +0400
Subject: [PATCH 107/161] #51371 fixed failing test in iossimulator (#63877)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* #51371 fixed failing test in iossimulator

* #51371 added skiptestexception

* #51371 added space after reference

* #51371 fixed remaining failing tests

* #51371 whitespace issue

* #51371 removed extra spaces

* Squashed commit of the following:

commit 36cdb5fc0c38cbb44291114e48e2b202ff37db01
Author: Ilona Tomkowicz <32700855+ilonatommy@users.noreply.github.com>
Date:   Thu Jan 20 11:03:02 2022 +0100

    [wasm][debugger] Added support for stepper boundary attribute (#63991)

    * Hidden methods and step through methods behave the same way.

    * Perpared flow for setting JustMyCode in the future.

    * Tests for JustMyCode setting before debug launch.

    * Transformed into dynamic JustMyCode change flow.

    * JustMyCode disabled, first 3 cases solved.

    * Finished behavior for JMC disabled (with 1 difference).

    * JMC enabled: stepIn np bp + stepIn bp + resume bp.

    * Functional version (with minor deviations from expected behavior).

    * Refactoring.

    * All tests for NonUserCode work.

    * Fix line number after adding code above.

    * Stepper boundary with tests.

    * Save information about multiple decorators.

    * Fix error in merge.

commit 5a523cf27a9b73e61adb1408f21b5e75a2246d9e
Author: Ilona Tomkowicz <32700855+ilonatommy@users.noreply.github.com>
Date:   Thu Jan 20 10:26:06 2022 +0100

    [debugger][wasm] Added support for non user code attribute (#63876)

    * Hidden methods and step through methods behave the same way.

    * Perpared flow for setting JustMyCode in the future.

    * Tests for JustMyCode setting before debug launch.

    * Transformed into dynamic JustMyCode change flow.

    * JustMyCode disabled, first 3 cases solved.

    * Finished behavior for JMC disabled (with 1 difference).

    * JMC enabled: stepIn np bp + stepIn bp + resume bp.

    * Functional version (with minor deviations from expected behavior).

    * Refactoring.

    * All tests for NonUserCode work.

    * Fix line number after adding code above.

    * Fix error in merge.

    * Removing duplicated tests.

commit 8f2c84f02b74dbbe6e1f02dc9be37cf3ee288d6e
Author: Peter Sollich <petersol@microsoft.com>
Date:   Thu Jan 20 10:06:45 2022 +0100

    Fix issues with verify_regions, clear_batch_mark_array_bits. (#63798)

    Details:
    - we cannot verify the tail of the region list from background GC, as it may be updated by threads allocating.
    - fix case in clear_batch_mark_array_bits where end is equal to the very end of a segment and we write into uncommitted memory in the mark_array.
    -  bgc_clear_batch_mark_array_bits did some checks and then called clear_batch_mark_array_bits which repeated the exact same checks. Renamed clear_batch_mark_array_bits to bgc_batch_mark_array_bits and removed the old copy, removed the declaration for clear_batch_mark_array_bits.

commit e4bfedd847990795eb28cda4008b5ff4c58fd561
Author: Jeremy Barton <jbarton@microsoft.com>
Date:   Thu Jan 20 00:06:28 2022 -0800

    Fix OpenSSL version check in GetAlpnSupport

    The previous check failed 3.0.0 because the Minor was 0 and Build was 0.

    It could probably be rewritten to be `>= new Version(1, 0, 2)`, but that'd require more thinking.

commit 2cf6b0d07309a3c19938f4c886fe13e8d5cc28ee
Author: Andrew Au <andrewau@microsoft.com>
Date:   Wed Jan 19 20:57:41 2022 -0800

    Fix gc_heap::remove_ro_segment (#63473)

commit 65a5d0e8a3027f2b240d098f47327ba3e1f743b1
Author: Tlakaelel Axayakatl Ceja <tlakaelel.ceja@microsoft.com>
Date:   Wed Jan 19 19:46:45 2022 -0800

    Add ProcessLinkerXmlBase to NativeAOT (#63666)

    Add Xml Parsing linker files as a reference source to NativeAOT
    Rename NativeAOT ProcessLinkerXmlBase version to ProcessXmlBase (uses XmlReader)
    Add ProcessLinkerXmlBase from linker and fix it so it can be used in NativeAOT (uses XPath)

commit f1c8b10ef824c5abf0c851f610ab0961ca31693f
Author: Egor Chesakov <Egor.Chesakov@microsoft.com>
Date:   Wed Jan 19 19:43:26 2022 -0800

    [Arm64] Keep unrolling InitBlock and CopyBlock up to 128 bytes (#63422)

    * Add INITBLK_LCL_UNROLL_LIMIT and CPBLK_LCL_UNROLL_LIMIT of 128 bytes in src/coreclr/jit/targetarm64.h

    * Keep unrolling InitBlock up to INITBLK_LCL_UNROLL_LIMIT bytes when dstAddr points to the stack in src/coreclr/jit/lowerarmarch.cpp

    * Keep unrolling CopyBlock up to CPBLK_LCL_UNROLL_LIMIT bytes when both srcAddr and dstAddr point to the stack in src/coreclr/jit/lowerarmarch.cpp

commit a5158df084780e52005e4dcbd02ee091542e06d0
Author: Will Smith <lol.tihan@gmail.com>
Date:   Wed Jan 19 18:44:19 2022 -0800

    'cmeq' and 'fcmeq' Vector64<T>.Zero/Vector128<T>.Zero ARM64 containment optimizations (#62933)

    * Initial work

    * Added a comma to display

    * Cleanup

    * Fixing build

    * More cleanup

    * Update comment

    * Update comment

    * Added CompareEqual Vector64/128 with Zero tests

    * Do not contain op1 for now

    * Wrong intrinsic id used

    * Removing generated tests

    * Removing generated tests

    * Added CompareEqual tests

    * Supporting containment for first operand

    * Fix test build

    * Passing correct register

    * Check IsVectorZero before not allocing a register

    * Update comment

    * Fixing test

    * Minor format change

    * Fixed formatting

    * Renamed test

    * Adding AdvSimd_Arm64 tests:

    * Adding support for rest of 'cmeq' and 'fcmeq' instructions

    * Removing github csproj

    * Minor test fix

    * Fixed tests

    * Fix print

    * Minor format change

    * Fixing test

    * Added some emitter tests

    * Feedback

    * Update emitarm64.cpp

    * Feedback

commit 68a923a24edb47f1d0e3c38a69d4091a7587bfc4
Author: Andrew Au <andrewau@microsoft.com>
Date:   Wed Jan 19 17:59:07 2022 -0800

    Check if the child object is in the heap range before object_gennum (#63970)

commit 752569f66bcde98fcc4dd1e651f9f1f138184c5c
Author: Andrew Au <andrewau@microsoft.com>
Date:   Wed Jan 19 17:58:39 2022 -0800

    Check if the child object is in the heap range before get_region_plan_gen_num (#63828)

commit 5cefc0f9e618e2d8b38d7de67bbd8a50adb9646f
Author: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date:   Thu Jan 20 04:23:50 2022 +0300

    Fix invalid threading of nodes in rationalization (#64012)

    The code in question assumes that the ASG will be
    reversed and thus threads "simdTree" before "location"
    in the linear order. That dependency, while valid,
    because "gtSetEvalOrder" will always reverse ASGs
    with locals on the LHS, is unnecessary and incorrect
    from the IR validity point of view.

    Fix this by using "InsertAfter" instead of manual
    node threading.

commit 93dc760481bdde2c463d725c2927b9da8787eb98
Author: Tomáš Rylek <trylek@microsoft.com>
Date:   Thu Jan 20 01:52:15 2022 +0100

    Fix Crossgen2 bug #61104 and add regression test (#63956)

    The issue tracks the runtime regression failure where
    Crossgen2-compiled app is unable to locate a type with non-ASCII
    characters in its name. The failure was caused by the fact that
    Crossgen2 was incorrectly zero-extending the individual UTF8 characters
    when calculating the hash whereas runtime is sign-extending them.

    Thanks

    Tomas

commit 94b699cc6f6b88c6de1d13152143d32285c59555
Author: Jeremy Koritzinsky <jekoritz@microsoft.com>
Date:   Wed Jan 19 16:46:00 2022 -0800

    Update StructMarshalling design now that DisableRuntimeMarshallingAttribute is approved (#63765)

    Co-authored-by: Elinor Fung <elfung@microsoft.com>

commit a618086f53fa755732697fba171a16e8bf67900a
Author: Andy Ayers <andya@microsoft.com>
Date:   Wed Jan 19 16:01:16 2022 -0800

    JIT: fix up switch map for out-of-loop predecessor (#64014)

    If we have a loop where some of the non-loop predecessors are switchs, and
    we add pre-header to the loop, we need to update the switch map for those
    predecessors.

    Fixes #63982.

commit 7f828a7e6b712bdeab02d75160249cd13c26a467
Author: Egor Bogatov <egorbo@gmail.com>
Date:   Thu Jan 20 02:08:10 2022 +0300

    [arm64] JIT: Redundant zero/sign extensions after ldrX/ldrsX (#62630)

commit ae1b755cd074745b0f09e826d3c7064b2a8f20dd
Author: Dan Moseley <danmose@microsoft.com>
Date:   Wed Jan 19 16:07:53 2022 -0700

    Retries for flaky WMI test (#64008)

commit 54eec5d1f4d7ded21e33e65c63ada26afe80b208
Author: Elinor Fung <elfung@microsoft.com>
Date:   Wed Jan 19 14:23:48 2022 -0800

    Make ILStubGenerated event log ModuleID corresponding to that on other events (#63974)

commit 97fec41a752f067f4d6dde170073300e1184693b
Author: Santiago Fernandez Madero <safern@microsoft.com>
Date:   Wed Jan 19 14:18:21 2022 -0800

    Add runtime-extra-platforms pipeline to have matching runtime PR and Rolling builds (#62564)

    * Add runtime-extended-platforms pipeline to have matching runtime PR and Rolling builds

    * Fix evaluate changed paths condition for the extra pipeline

    * PR Feedback and fix condition

    * Move MacCatalyst back to staging, disable tvOS tests

    * Disable browser wasm windows legs

commit 826e03e4b984d3bb76b2ead5f6ebb847be9c616f
Author: Jeremy Koritzinsky <jekoritz@microsoft.com>
Date:   Wed Jan 19 14:08:07 2022 -0800

    Bump Explicit-layout value types with no fields to at minimum 1 byte size. (#63975)

commit 6f8d8b20a0c78dcfc09ea7a43db48a9a4e055e13
Author: Ankit Jain <radical@gmail.com>
Date:   Wed Jan 19 16:41:04 2022 -0500

    Disable hot reload tests for AOT configurations (#64006)

commit 675c16711007536120fa2ef7b69224e44299d1e3
Author: Egor Chesakov <Egor.Chesakov@microsoft.com>
Date:   Wed Jan 19 12:59:49 2022 -0800

    [Arm64] Don't use D-copies in CopyBlock (#63588)

    * Increase the maximum number of internal registers allowd per node in src/coreclr/jit/lsra.h

    * Based on discussion in https://github.com/dotnet/runtime/issues/63453 don't allocate a SIMD register pair if the JIT won't be able to use Q-copies in src/coreclr/jit/lsraarmarch.cpp

    * Update CodeGen to reflect that Q-copies should be used only when size >= 2 * FP_REGSIZE_BYTES and using of them makes the instruction sequence shorter in src/coreclr/jit/codegenarmarch.cpp

    * Update comment - we don't use D-copies after that change in src/coreclr/jit/codegenarmarch.cpp

commit ac4c7fb9457a8b0972686b017d82367d7a9bf1ca
Author: Pavel Savara <pavelsavara@microsoft.com>
Date:   Wed Jan 19 20:59:01 2022 +0100

    - mono_wasm_new_external_root for roots on stack (#63997)

    - temp_malloc helper via linear buffer in js
    - small refactorings
    Co-authored-by: Katelyn Gadd <kg@luminance.org>

commit 65db54e2a92a2ef8ba8a75c70990e78f21818e18
Author: Egor Bogatov <egorbo@gmail.com>
Date:   Wed Jan 19 22:23:45 2022 +0300

    Add IsKnownConstant jit helper and optimize 'str == ""' with str.StartsWith('c') (#63734)

    Co-authored-by: Miha Zupan <mihazupan.zupan1@gmail.com>
    Co-authored-by: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>

commit ded841a690e73c04ebdc86c681893bf9fd372751
Author: Egor Bogatov <egorbo@gmail.com>
Date:   Wed Jan 19 22:22:49 2022 +0300

    Don't reuse registers in Debug mode (#63698)

    Co-authored-by: Bruce Forstall <brucefo@microsoft.com>

commit 67848f23d51562bd2e54f6490f5aad22f57baffe
Author: Brennan <brecon@microsoft.com>
Date:   Wed Jan 19 11:01:24 2022 -0800

    [RateLimiting] Dequeue items when queuing with NewestFirst (#63377)

commit 12f434db114e629854e7d5eb966e07d24e243712
Author: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date:   Wed Jan 19 20:42:27 2022 +0200

    Fix for Werror=use-after-free in PAL (#63954)

    * Fix for Werror=use-after-free in PAL

    * Delete Local{Alloc,Free}

    * Delete LMEM_* macros

    * Delete PAL_dladdr

commit bbbfba31b61a2299c434172f709716325c073ef8
Author: Stephen Toub <stoub@microsoft.com>
Date:   Wed Jan 19 12:27:25 2022 -0500

    Use IndexOf in StringBuilder.Replace(char, char) (#63913)

commit df049b9a23c5182bf7f26f224b69bf1f47f9dc2f
Author: Dan Moseley <danmose@microsoft.com>
Date:   Wed Jan 19 09:26:30 2022 -0700

    Disable 2 SMTP tests on checked runtime (#63947)

commit 8604989022950ef38f94b9150043b31d81f061a5
Author: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date:   Wed Jan 19 17:49:39 2022 +0200

    [Group 5] Enable nullable annotations for `Microsoft.Extensions.Configuration.Json` (#63694)

    * Nullable enable

commit a8c1408084714a7db13db7eb5cae10b209d9c096
Author: TobiasLaving <95348503+TobiasLaving@users.noreply.github.com>
Date:   Wed Jan 19 16:04:02 2022 +0100

    Update runtime.json with manjaro information (#63338)

    Without specifying runtime on manjaro we cannot run the projects.
    FYI: Manjaro has a "ID_LIKE" param in os_release that has arch as input. Perhaps that would be another way forward.

commit 31f20c54ad56946a506d705261a5445930b56d29
Author: Stephen Toub <stoub@microsoft.com>
Date:   Wed Jan 19 09:57:04 2022 -0500

    Improve auto-atomicity for conditionals (#63299)

    - Allow for automatically making loops that end conditional branches be atomic
    - Allow for using a following expression conditional to make a prior loop atomic
    - Allow conditionals to influence the computed minimum length

commit 8fe0467efd29d952fc2afbf302c1d8a1bb3b2fa5
Author: Maxim Lipnin <v-maxlip@microsoft.com>
Date:   Wed Jan 19 16:55:40 2022 +0300

    Take MacCatalyst into account in EnvironmentTests.WorkingSet_Valid test (#63995)

    Follow-up on https://github.com/dotnet/runtime/pull/63934

commit b042bc3043f3f7f475f5bd6e8f58df2952dd9250
Author: Radek Zikmund <32671551+rzikm@users.noreply.github.com>
Date:   Wed Jan 19 14:15:57 2022 +0100

    Avoid allocating byte array when setting ALPN list on Linux (#63674)

    * Avoid allocating byte array when setting ALPN list

    * Code review feedback

    * Apply suggestions from code review

    Co-authored-by: Stephen Toub <stoub@microsoft.com>

    * Slice the stackalloc'd buffer to correct length

    Co-authored-by: Miha Zupan <mihazupan.zupan1@gmail.com>

    * Code review fixes

    Co-authored-by: Stephen Toub <stoub@microsoft.com>
    Co-authored-by: Miha Zupan <mihazupan.zupan1@gmail.com>

commit 34794bc5f2bcdbaa9057bb07b8764e2bb6a411a2
Author: Krzysztof Wicher <kwicher@microsoft.com>
Date:   Wed Jan 19 13:45:01 2022 +0100

    Enable System.Text.Json tests on netfx (#63803)

    * Enable System.Text.Json tests on netfx

    * use NETFRAMEWORK define

    * disable another two test cases after rebase

    * disable last test case which repros only on CI for me

    * add p2p only on netfx

commit e54df94bc9a5e1e064835be817d3e9ac773e1d9a
Author: Eirik Tsarpalis <eirik.tsarpalis@gmail.com>
Date:   Wed Jan 19 11:59:34 2022 +0000

    Replace "needs more info" label with "needs-author-action" (#63899)

commit a5292a6b54ca743efe2e5b6776864efb7c7702a5
Author: Olivier Giniaux <oginiaux@gmail.com>
Date:   Wed Jan 19 12:56:54 2022 +0100

    Fix profiling objectsallocatedbyclass (#63814)

    * Add test for ObjectsAllocatedByClass profiler callbacks

    * Fix ObjectsAllocatedByClass profiler callbacks based on wrong flag

    * Fix wrong args in test log

    Co-authored-by: Olivier Giniaux <oginiaux@smartadserver.com>

commit 6e4dfbfe2db42c9c67f1094dd65ec683c44e3457
Author: Stephen Toub <stoub@microsoft.com>
Date:   Wed Jan 19 06:53:36 2022 -0500

    Improve reductions for Regex empty / nothing nodes (#63695)

commit 777c353c767c588824a489ad39238fef01c80f4e
Author: Stephen Toub <stoub@microsoft.com>
Date:   Wed Jan 19 06:53:24 2022 -0500

    Extend regex switch alternation optimization to IgnoreCase (#63756)

    IgnoreCase now results in producing sets (e.g. an 'a' becomes '[Aa]') but the source generator's optimization that produces a switch statements for alternations with non-overlapping branches doesn't yet understand such sets.  This augments that logic to fix that.

commit a25536f790258fe68240feff864713e8d20b418c
Author: Stephen Toub <stoub@microsoft.com>
Date:   Wed Jan 19 06:52:15 2022 -0500

    Improve auto-atomicity for Regex loops (#63986)

    - As part of recognizing loops that could be made atomic, we currently only look at the node guaranteed to come immediately after it, e.g. in a+b+c+, when analyzing a+ we only look at the b+.  That's fine in many cases, but if our expression was instead e.g. a*b*c*, we couldn't make a* atomic because we wouldn't be guaranteed it'd be followed by a b, and we wouldn't look at the subsequent nodes to determine what else might follow.  When that situation occurs, we can now walk the tree to find the next node, and repeatedly do so as much as is needed in order to find the next node, enabling us to make all of those loops atomic.
    - We currently perform the auto-atomicity reduction for single-char loops as part of reducing concatenations.  But this means we're performing that transformation at a time when the tree isn't fully formed, which means we can't necessarily reach out of a concatenation to what comes after it and use that to influence the atomicity.  It also means we might repeat the analysis unnecessarily multiple times, because it's done as part of parenting a node.  We can instead do that optimization as part of the final optimization phase, after the tree is already created.
    - When we find a lazy loop at the end of an expression, we can treat it as atomic, which means we can lower its max bound to its min bound.
    - When we encounter a loop (lazy or greedy) at the end of an expression, if it has a max bound of 1 (i.e. it's optional), we can proceed to eliminate ending backtracking with its child regardless of whether the child could be made atomic with the start of the loop, since it won't ever repeat more than once.

commit eeaee44e6fe4425db044967e025255e6a12c97a9
Author: dotnet-maestro[bot] <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date:   Wed Jan 19 11:20:02 2022 +0100

    [main] Update dependencies from dotnet/runtime dotnet/arcade dotnet/xharness dotnet/icu dotnet/roslyn-analyzers dotnet/llvm-project (#63737)

    Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
    Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>

commit 313baef638104ed64f93e077c84547421884c91b
Author: Egor Bogatov <egorbo@gmail.com>
Date:   Wed Jan 19 13:16:28 2022 +0300

    JIT: Fix repeatable failure for max CALLSITE_DEPTH (#63966)

commit a354bb152f4e505d53034c3538f971ad4c2f18ac
Author: Stephen Toub <stoub@microsoft.com>
Date:   Wed Jan 19 04:10:27 2022 -0500

    Address follow-up feedback to CachedCompletedInt32Task (#63968)

commit b68cf65634bb0d6a1a7e588568959cdc33a0322c
Author: Adam Sitnik <adam.sitnik@gmail.com>
Date:   Wed Jan 19 08:58:20 2022 +0100

    Reading beyond EOF should return 0 for FILE_FLAG_NO_BUFFERING (#63625)

    * move Length to SafeFileHandle, so it's cached value can be reused in more places

commit ea2a98163327022e6cefb6a424de4cb4e9618277
Author: Ilona Tomkowicz <32700855+ilonatommy@users.noreply.github.com>
Date:   Wed Jan 19 08:55:35 2022 +0100

    [wasm][debugger] Added support for StepThroughAttribute (#63679)

    * Hidden methods and step through methods behave the same way.

    * Perpared flow for setting JustMyCode in the future.

    * Tests for JustMyCode setting before debug launch.

    * Transformed into dynamic JustMyCode change flow.

    * JustMyCode disabled, first 3 cases solved.

    * Finished behavior for JMC disabled (with 1 difference).

    * JMC enabled: stepIn np bp + stepIn bp + resume bp.

    * Functional version (with minor deviations from expected behavior).

    * Refactoring.

commit 00e13f5482ea1156e6b37ea5d242d7f27befb8d3
Author: Adam Sitnik <adam.sitnik@gmail.com>
Date:   Wed Jan 19 08:42:07 2022 +0100

    Add tests for creating memory mapped files from non-seekable files (#63927)

commit c66e3c49b59e0894ed3e7c41b0e78dcda22528ae
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Wed Jan 19 15:01:43 2022 +0900

    Add support for libraries testing with NativeAOT (#63781)

    This adds support for running libraries tests with NativeAOT. It reuses the single file xunit runner since we cannot `LoadFrom` the tests on NativeAOT. The strategy is the same as for single file testing: do a publish. To do the NativeAOT publish, we include the Microsoft.DotNet.ILCompiler.targets.

commit 3104ed8a3579746eaadb6280acc4fae1ae0df6ed
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Wed Jan 19 15:00:52 2022 +0900

    Fix up warnings from delegate thunks (#63980)

    If we hit a p/invoke with a `System.Delegate` in a delegate marshalling stub, blame the delegate type, not the compiler-generated method. Apparently we marshal System.Delegate in MsQuick interop.

commit 0b307c95286a4f468fbb627a66515054ff18dc87
Author: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date:   Wed Jan 19 07:25:12 2022 +0200

    Add managed implementation of Math/MathF.Abs (#63881)

    * Add managed implementation of  Math/MathF.Abs

    * Cleanup trailing whitespaces in changeset

    * Delete unused _copysignf macro

commit fc3875f14f310cdce716df30a94feb43db79a28a
Author: Jose Perez Rodriguez <joperezr@microsoft.com>
Date:   Tue Jan 18 19:47:09 2022 -0800

    Fix case where we incorrectly select a prefix as a FindFirstChar optimization when the pattern includdes an alternation that could lead to different prefixes. (#63976)

commit 454ac0a6e7584e1c02677d459d20dae5df61fb47
Author: Stephen Toub <stoub@microsoft.com>
Date:   Tue Jan 18 22:15:32 2022 -0500

    Revert "Improve auto-atomicity for Regex loops (#63518)" (#63984)

    This reverts commit 557901e779a009cf4a51327963727a4d1ded0094.

commit da72791c37480532e647e8f69aff3f2b7eef6049
Author: Jan Kotas <jkotas@microsoft.com>
Date:   Tue Jan 18 18:59:04 2022 -0800

    Fix System.Reflection.Metadata version in ILVerification nuget package metadata (#63965)

    Fixes #63944

commit b7d8f5ecfa7bceb8069448951c7fabd65bcf26a0
Author: Tarek Mahmoud Sayed <tarekms@microsoft.com>
Date:   Tue Jan 18 18:39:37 2022 -0800

    Fix Failing Globalization Test on OSX (#63971)

commit 546c23804538ee751e4bb419942bc0170c3e5e06
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Wed Jan 19 10:58:17 2022 +0900

    Improve ILLink.targets integration (#63914)

    Runtime side of https://github.com/dotnet/sdk/pull/23470 (depends on that getting merged). Skip touching the IL Linker semaphore that tricks the target into not running.

commit 557901e779a009cf4a51327963727a4d1ded0094
Author: Stephen Toub <stoub@microsoft.com>
Date:   Tue Jan 18 20:40:35 2022 -0500

    Improve auto-atomicity for Regex loops (#63518)

    * Improve auto-atomicity for Regex loops

    - As part of recognizing loops that could be made atomic, we currently only look at the node guaranteed to come immediately after it, e.g. in a+b+c+, when analyzing a+ we only look at the b+.  That's fine in many cases, but if our expression was instead e.g. a*b*c*, we couldn't make a* atomic because we wouldn't be guaranteed it'd be followed by a b, and we wouldn't look at the subsequent nodes to determine what else might follow.  When that situation occurs, we can now walk the tree to find the next node, and repeatedly do so as much as is needed in order to find the next node, enabling us to make all of those loops atomic.
    - We currently perform the auto-atomicity reduction for single-char loops as part of reducing concatenations.  But this means we're performing that transformation at a time when the tree isn't fully formed, which means we can't necessarily reach out of a concatenation to what comes after it and use that to influence the atomicity.  It also means we might repeat the analysis unnecessarily multiple times, because it's done as part of parenting a node.  We can instead do that optimization as part of the final optimization phase, after the tree is already created.
    - When we find a lazy loop at the end of an expression, we can treat it as atomic, which means we can lower its max bound to its min bound.
    - When we encounter a loop (lazy or greedy) at the end of an expression, if it has a max bound of 1 (i.e. it's optional), we can proceed to eliminate ending backtracking with its child regardless of whether the child could be made atomic with the start of the loop, since it won't ever repeat more than once.

    * Extend auto-atomicity to lazy loops

commit 14ebc594b2757e29e1f73742ce37d68f855c0a3c
Author: Jan Kotas <jkotas@microsoft.com>
Date:   Tue Jan 18 17:36:09 2022 -0800

    Do not register ACTIVATION_SIGNAL for secondary PAL copies (#63961)

    Related to #63959

commit cde93b69b6b099627d3615ec7f54cfb28b25bcde
Author: Andy Ayers <andya@microsoft.com>
Date:   Tue Jan 18 16:57:51 2022 -0800

    JIT: yet another OSR stress mode (#62980)

    Existing OSR stress use existing patchpoint placement logic and alter the
    policy settings so that OSR methods are created more eagerly.

    This new version of OSR stress alters the patchpoint placement logic, to
    add patchpoints to more places. In conjunction with the eager policy stress
    above this leads to creation and execution of large numbers of OSR methods.

    Any IL offset in the method with an empty stack (and not in a handler) is fair
    game for a patchpoint, so this new method randomly adds patchpoints to the
    starts of blocks when stack empty (future work may extend this to mid-block
    stack empty points).

    The new mode is enabled by setting `COMPlus_JitRandomOnStackReplacement` to a
    non-zero value; this value represents the likelihood of adding a patchpoint
    at a stack-empty block start, and also factors into the random seed. (Recall
    this is parsed in hex, so 0x64 == 100 or larger will put a patchpoint at the
    start of every stack empty block).

    Various values are interesting because once a method reaches a patchpoint
    and triggers OSR, the remainder of that method's execution is in the OSR method,
    so later patchpoints in the original method may never be reached. So some sort
    of random/selective patchpoint approach (in conjunction with varying policy
    settings) is needed to ensure that we create an execute as many different OSR
    variants as possible.

    This PR also includes a couple of fixes exposed by local testing of this new
    stress mode:
    * The OSR prolog may end up empty, which gcencoder doesn't like. Detect this
    and add a `nop` for the prolog.
    * If we're importing the `fgEntryBB` during OSR, we don't need to schedule it
    for re-importation. This happens if we put a patchpoint at IL offset zero.
    * Update the selective dumping policy `COMPlus_JitDumpAtOSROoffset` to only
    dump OSR method compilations.

    A new test leg is added to `jit-experimental` to run with this mode enabled
    with a probability of 21% (0x15) and quick OSR triggers.

    Also included:
    * fix probability calc
    * remove obsolete assert
    * osr exposed does not apply to simd
    * only pad zero-sized OSR prolog if we're reporting generic context
    * Add ability to have patchpoint at specified offset.
    * Fix interaction of stress patchpoints and profile instrumentation.
    We need to force block-based instrumentation if we might have stress
    patchpoints.

commit 93cb3559a17aca424e3ce1206a71496da2c34b69
Author: Honza Rameš <ramejan@gmail.com>
Date:   Wed Jan 19 01:12:18 2022 +0100

    Reduce allocations in code generated by Logging generators (#61162) (#62011)

commit c50185bb24ace683f2ce6c5e4351ce2104bd1349
Author: Aleksey Kliger (λgeek) <alklig@microsoft.com>
Date:   Tue Jan 18 18:40:42 2022 -0500

    [mono] Hot Reload: initial push to support adding lambdas (#63513)

    Adds support for:
    * Adding static lambdas to existing methods, whether or not they had lambdas before.
    * Adding lambdas that capture `this` to existing methods that already captured `this` before
    * Adding new static or instance methods to existing types
    * Adding static fields to existing types
    * Adding new types (note that adding instance fields currently will fail.  It'll go in in a future PR that will address https://github.com/dotnet/runtime/issues/63643).

    Note that reflection on newly added members isn't tested yet and likely doesn't work.

    Fixes https://github.com/dotnet/runtime/issues/50249

    Contributes to https://github.com/dotnet/runtime/issues/57365

    * Add AddStaticField test; cleanup AddLambdaCapturingThis

    * Add AddNestedClass testcase

    * hot_reload: add a comment about remaining work

    * move per-class metadata update info to MonoClassMetadataUpdateInfo

       Use a property on the class instead of a hash table in the baseline image to keep track of added fields and methods

    * Cleanup pass1 to check add/update against prior gen

       Instead of the baseline image

    * adding a class

       Working on making mono_metadata_nested_in_typedef do the right thing for nested classes

       Contributes to making mono_class_create_from_typedef do the right thing for nested classes.

    * fix: correct mutant table population when the baseline table is empty

       In that case the table row_size and size_bitmap of the baseline are both 0, so offset calculations don't work.

       In that case when we know we need to add rows to the mutant table, use the uncompressed layout (32-bit columns, always) same as the EnC delta.

    * Calling new methods on a nested class works

    * adding fields

       Doesn't work yet.  Dies in mono_class_get_field, called from mono_field_from_token_checked.

       The problem we're going to have to deal with is that unlike MonoMethod which is allocated upon lookup, the MonoClassFields of a class are allocated contiguously in class initialization.  And there are not really enough fields in MonoClassField to indicate "this is not an ordinary field, don't do pointer arithmetic with it".  One idea is to steal a bit from MonoClassField:parent and always check it as a trigger to go on a slower path.

    * adding static fields

       Rework the delta info to store info about "members" (rather than methods and fields separately).

       Add a MonoClassMetadataUpdateField subclass of MonoClassField that has extra info.

       Add new component methods to go from a MonoClassField to an index, and from a field token to a MonoClassField.

       Set MonoClassField:offset to -1 to generally go down the "special static field" codepath since we will need to do some one-off work to make a storage area for added static fields.

       Instance fields are not supported yet and error out during the update pass for now.

    * fix custom attribute lookups on new classes/methods/fields

    * Add a sketch of HotReloadInstanceFieldTable

       This is a class that manages the lifetime for added instance fields for reference types that had new fields added to them by EnC   It's basically ConditionalWeakTable<object, Dictionary<uint, Store>> where the outer key is the object instance, the inner key is the fielddef token, and the value is a Store.  The store has a single object? field which the location where the field's value will go.  For reference types this is the reference directly, and for valuetypes and primitives, this is the boxed object (so to get the actual storage address you need to add sizeof(MonoObject)).

    * mono_metadata_update_get_static_field_addr

       two reminders:

       1. The static field area needs to be GC-visible
       2. We should really handle added fields on un-inited classes by allocating the instances in the normal way - in the layout algorithm.

    * Free MonoClassMetadataUpdateInfo when BaselineInfo is destroyed

    * placeholder struct for runtime class data; instance offset placeholder

    * static field storage

       Need to store the fields in a GC root, and in pinned allocations.

    * Implement hot_reload_get_static_field_addr()

    * Add mono_metadata_update_find_method_by_name

       Now we can find .cctor

       This is enough that a basic sample with an added static lambda works

    * Fix infinite loop

    * fix build

    * fix dynamic components builds

    * fix windows build

    * Fix inadvertent fallthru in previous fix

    * Report new capabilities

       NewTypeDefinition is not completely functional because adding instance fields is not supported yet.   But adding classes with only static methods works.

    * tests: describe what existing tests do, add placeholder static lambda test

    * tests: Add AddStaticLambda test case

       Adding a brand new static lambda to an existing method body is supported

    * Destroy the runtime part of MonoClassMetadataUpdateInfo, too

    * rename Mono.HotReload file

       it has more classes than just the instance table

    * tests: add ActiveIssue for supporting adding instance fields

    * ifdef out Mono.HotReload.InstanceFieldTable

       it's not ready yet

    * Remove get_added_members from hot reload component interface

       Doesn't seem necessary to expose this yet.  It's only used in hot_reload.c right now

    * Change the AddStaticLambda sample to use Func<string,string>

       To check that lambdas with parameters work

    * Use a mempool allocated GSlist for the added members

       This avoids invalidating iterators in case we add members on one thread while another thread is iterating.

       If it turns out we need random access, we can switch to a GArray with locking.  But so far we only ever iterate.

    * Use mono_get_corlib instead of passing MonoDefaults to hot_reload

    * use normal GENERATE_TRY_GET_CLASS_WITH_CACHE

    * [metadata] make m_field_set_parent and m_field_set_meta_flags inline

       m_ prefix functions are supposed to be inline

commit d2844ebf57568de4926517c521a94a721d9c26a8
Author: Bradley Grainger <bgrainger@gmail.com>
Date:   Tue Jan 18 15:32:16 2022 -0800

    Add `UnicodeRange.ArabicExtendedB` (#63901)

commit 8d5f5267d33f7703c014cc89670f1f7aa47544f9
Author: Andrii Kurdiumov <kant2002@gmail.com>
Date:   Wed Jan 19 05:23:32 2022 +0600

    Update links to the project for DllImportGenerator (#63940)

    As coincidence, I think `RestoreAdditionalProjectSources` not needed anymore.

commit 83b52cdc310ebd77cddff7efd772a0800a403f47
Author: Alexander Köplinger <alex.koeplinger@outlook.com>
Date:   Tue Jan 18 23:13:58 2022 +0100

    [iOS/tvOS] Remove P/Invokes to libproc from System.Private.CoreLib (#63934)

    They aren't allowed by Apple when submitting to the App Store.

    Finishes https://github.com/dotnet/runtime/issues/61265

commit b0de23b1677fbaf4fbcde814ec0bad6f60094920
Author: Andy Gocke <angocke@microsoft.com>
Date:   Tue Jan 18 13:37:41 2022 -0800

    Revert "Enable GC Regions by default (#59283)" (#63935)

    This reverts commit cf91716.

    This looks to be creating a lot of crashes in a lot of different unit tests on Mac. Reverting seems to halt the Mac failures (see https://dev.azure.com/dnceng/public/_build/results?buildId=1557880)

    Fixes #63439

commit 0266f034221188bc7d0156ba76a571c71885c68f
Author: Kunal Pathak <Kunal.Pathak@microsoft.com>
Date:   Tue Jan 18 11:04:48 2022 -0800

    Fix decoding errors (#63929)

commit 078da6c37e2ab602fe37ab699051ef71161ce2cc
Author: Bruce Forstall <brucefo@microsoft.com>
Date:   Tue Jan 18 11:04:22 2022 -0800

    Introduce `BasicBlock::KindIs()` for checking bbJumpKind (#63203)

    * Introduce `BasicBlock::KindIs()` for checking bbJumpKind

    This can simplify code that is checking for multiple `bbJumpKind` kinds with
    an `if` statement, where a `switch` is not warranted. It's the same
    usage model as `GenTree::OperIs()`.

    e.g.,
    ```
    if (block->KindIs(BBJ_COND, BBJ_SWITCH, BBJ_RETURN))
    ```

    * Fix argument name

commit 82b8d79b6f858f0d44791e3eab36735b7093d935
Author: Shane Krueger <shane@acdmail.com>
Date:   Tue Jan 18 13:56:09 2022 -0500

    Fix NullabilityInfoContext.Create to properly analyze types with nested generic types (#63556)

commit f04a24249835096eea1a1a66e4af03cfec5ed32b
Author: Artem Kliatchkine <artem.kliatchkine@gmail.com>
Date:   Tue Jan 18 18:18:45 2022 +0100

    Set zero (infinite) options timeout in case of Timeout.InfiniteTimeSpan (#55984) (#63733)

    Co-authored-by: Artem Kliatchkine <eldog@rambler.ru>

commit 2eb2e883dc807897fe07dd6559462e37e8613693
Author: Tomas Weinfurt <tweinfurt@yahoo.com>
Date:   Tue Jan 18 09:18:29 2022 -0800

    improve protocol detection in jail (#63565)

    * improve protocol detection in jail

    * add comment

commit d18d6c703295555d466fb159f8dec64857f68ed9
Author: Kevin Jones <kevin@vcsjones.com>
Date:   Tue Jan 18 12:15:11 2022 -0500

    Update SAN test to account for OpenSSL 3 changes

commit 64896116e66377aa8e951abb9e9505aff8a25f89
Author: Kevin Jones <kevin@vcsjones.com>
Date:   Tue Jan 18 11:36:15 2022 -0500

    Fix OpenSSL 3 reporting an OutOfMemoryException for missing private key

commit 5a12420546d7f0d963bcccf082400c1b057e38ef
Author: Maxim Lipnin <v-maxlip@microsoft.com>
Date:   Tue Jan 18 18:21:33 2022 +0300

    Remove individual exclusions for DllImportGenerator.Unit.Tests in favor of the general one for the entire set of mobile targets (#63924)

commit 39ef452edcf90bae76a1e4c8c1c24209e17ac5f2
Author: Maxim Lipnin <v-maxlip@microsoft.com>
Date:   Tue Jan 18 18:20:15 2022 +0300

    Disable DllImportGenerator.Unit.Tests test suite on macOS+arm64+CoreCLR (#63887)

commit 856e8c3510cb0aaaa3b1a1679552c03ae5308b9e
Author: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date:   Tue Jan 18 17:16:10 2022 +0200

    Fix compilation with older gcc (#63721)

commit 2f366a85444570429f8739b13bde18226a10bc86
Author: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date:   Tue Jan 18 17:12:47 2022 +0200

    Delete a few unused PAL APIs (#63916)

    * Delete _fullpath PAL API

    * Delete PAL_wcscspn

    * Delete PAL_wcstok

commit 207590a7b82afa086e889f3fc695b104713f7c8e
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Wed Jan 19 00:10:36 2022 +0900

    Fold coreclr/ToolBox into coreclr/tools (#63917)

    This separation only existed because of Razzle build sequencing of desktop CLR. It doesn't make sense for CoreCLR. The only thing the extra directory is doing now is that it breaks tab completion when navigating the CoreCLR source tree because ToolBox comes before tools alphabetically and most things live in tools.

commit e30fe9b4d3afabc4acdfcaa539ecf213c16aea1a
Author: Theodore Tsirpanis <teo@tsirpanis.gr>
Date:   Tue Jan 18 16:58:11 2022 +0200

    Encapsulate the logic of caching the last synchronously completed task. (#61781)

    * Encapsulate the logic of caching the last synchronously completed task.

    * Apply suggestions from code review

    Co-authored-by: Adam Sitnik <adam.sitnik@gmail.com>

commit e6ad043996419f04b1c0ae9fea113318f61e234f
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Tue Jan 18 23:32:28 2022 +0900

    Split CheckNotDisposed to allow inlining (#63863)

    * Split CheckNotDisposed to allow inlining

    `CheckNotDisposed` is not getting inlined because RyuJIT thinks it's not profitable (ldstr/newobj/throw is expensive). If we extract the rare path into a separate method, it changes the profitability math and allows inlining to happen.

    * Review feedback

commit dfb36ae68d9a099c9b90317c97bdf485bab4121e
Author: Stephen Toub <stoub@microsoft.com>
Date:   Tue Jan 18 09:31:12 2022 -0500

    Fix a few IndexOf{Any} uses (#63852)

commit 7a0388a9f1a11b723aa09aeae3436a078b32bb43
Author: Eirik Tsarpalis <eirik.tsarpalis@gmail.com>
Date:   Tue Jan 18 13:33:57 2022 +0000

    Extend triage board automation to more pods (#63897)

commit 8d8ef6dac58acf2ab944289c69dd46ee9e12d717
Author: Tom Deseyn <tom.deseyn@gmail.com>
Date:   Tue Jan 18 11:00:35 2022 +0100

    FileSystemEntry.Unix: don't make a syscall to check hidden on Linux. (#63878)

commit 24bdc3844c3de6d6a3c47534411c8322ae1a7bc6
Author: dotnet-maestro[bot] <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date:   Tue Jan 18 10:41:02 2022 +0100

    [main] Update dependencies from dotnet/linker (#63445)

    Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

commit 126db6dd10fcf618a9ab17ed93347044cc5a3a24
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Tue Jan 18 14:19:20 2022 +0900

    Disable warnings as errors in the repro project (#63910)

commit d0e2dac3a828b6afda5cff812b7b09b9dba213b7
Author: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date:   Tue Jan 18 01:23:41 2022 +0300

    Actually properly type primary selectors (#63752)

    * Use only one [out] parameter in IsFieldAddr

    Since only one is needed.

    * Actually properly type primary selectors

commit d48a44f2ee2f6b4b039ca10cfd5dc01c331669f5
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Tue Jan 18 02:11:44 2022 +0900

    Separate variance information in mangled names (#63866)

    Fixes https://github.com/dotnet/runtimelab/issues/1821.

    Eventually we'll need to have a holistic look at how we mangle things.

commit 6dcb03913c7d55dca824abcd21617212bef62553
Author: Jan Kotas <jkotas@microsoft.com>
Date:   Mon Jan 17 07:46:40 2022 -0800

    Delete UMThkCallFrame (#63826)

    * Delete UMThkCallFrame

    * Place UnmanagedToManagedFrame under FEATURE_COMINTEROP

commit 4fac9549fea1ccbf296aeaa0861478825d70c5c3
Author: Mandar Sahasrabuddhe <WinCPP@users.noreply.github.com>
Date:   Mon Jan 17 16:05:28 2022 +0530

    Fix escaped strings for TryGetDateTime(Offset) (#63534)

    * Fix escaped strings for TryGetDateTime(Offset)

    Fix the exception thrown when the escaped DateTime(Offset)
    property value is unescaped and it becomes shorter than
    the minimum expected length. In such case the Try* method
    should fail and returns false.

    Fixes #62720

    * Fix escaped strings for TryGetDateTime(Offset)

    Fix the exception thrown when the escaped DateTime(Offset)
    property value is unescaped and it becomes shorter than
    the minimum expected length. In such a case, the Try* method
    should fail and return false.

    Fixes #62720

    * Fix escaped strings for TryGetDateTime(Offset)

    Fix the exception thrown when the escaped DateTime(Offset)
    property value is unescaped and it becomes shorter than
    the minimum expected length. In such a case, the Try* method
    should fail and return false.

    Fixes #62720

    * Fix escaped strings for TryGetDateTime(Offset)

    Fix the exception thrown when the escaped DateTime(Offset)
    property value is unescaped and it becomes shorter than
    the minimum expected length. In such a case, the Try* method
    should fail and return false.

    Fixes #62720

    * Fix escaped strings for TryGetDateTime(Offset)

    Fix the exception thrown when the escaped DateTime(Offset)
    property value is unescaped and it becomes shorter than
    the minimum expected length. In such a case, the Try* method
    should fail and return false.

    Fixes #62720

commit d72ed27cfe8656807ece255b275ca9d617af073b
Author: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date:   Mon Jan 17 13:11:43 2022 +0300

    Treat CLS_VAR_ADDR as never null (#63844)

    Allows the LIR DCE to remove some indirections that
    were previously incorrectly thought to be throwing.

    Contributes to CLS_VAR deletion (by minimizing the diffs).

commit bf1d4a10b998a80b92728f80aa5ebbcd5138347a
Author: Radek Zikmund <32671551+rzikm@users.noreply.github.com>
Date:   Mon Jan 17 11:11:10 2022 +0100

    Fix generating RunTests.sh and RunTests.cmd scripts (#63875)

    This fixes issue where generated RunTests.sh in the "To repro directly: "
    section contained unevaluated variables like RUNTIME_PATH, which
    prevented simple copy-pasting the code into the terminal

commit ae2f60c950cc021921fce83c796cbcb5ff96c658
Author: Andrii Kurdiumov <kant2002@gmail.com>
Date:   Mon Jan 17 09:57:15 2022 +0600

    NativeAOT: Allow Delegate and MulticastDelegate marshalling (#63219)

    - Closes https://github.com/dotnet/runtimelab/issues/1107
    - Progress towards https://github.com/GtkSharp/GtkSharp/issues/300

commit 84926be4243143b7830e78cb7727057ed711a3cc
Author: Andrii Kurdiumov <kant2002@gmail.com>
Date:   Mon Jan 17 07:42:08 2022 +0600

    Prevent assert if stack trace has function pointer (#63787)

commit 217b288cfabd2368082343c7e36e7ac0a8f96db9
Author: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date:   Mon Jan 17 03:10:54 2022 +0200

    Convert h2inc to a cmake function (#63841)

    * Convert h2inc to a cmake function

    * Reuse preprocess_file

commit ec349cd8e9960ec44bf528eef52c56a87e601207
Author: Tomáš Rylek <trylek@microsoft.com>
Date:   Sun Jan 16 20:50:01 2022 +0100

    Fix a few IL tests using the namespace syntax without an actual namespace (#63772)

commit 4f34cedc8eefb2a396646a67869e784f06d7def8
Author: Tomáš Rylek <trylek@microsoft.com>
Date:   Sun Jan 16 20:45:15 2022 +0100

    Disable the Runtime_34587 regression test with GH issue #63818 (#63819)

commit bf65675a8181d5448134788a148f844d35c4f091
Author: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date:   Sun Jan 16 20:21:52 2022 +0300

    Compress operand kinds array and optimize `OperIsLocal` (#63253)

    * Delete GTK_CONST

    * Delete OperIsRelop

    * Delete GTK_RELOP

    * Delete GTK_LOGOP

    * Delete GTK_LOCAL

    * Compress oper kinds

    They now fit into 8 bits.

commit 23de81782ca9cd24f024bd598563d363df29660c
Author: Zoltan Varga <vargaz@gmail.com>
Date:   Sat Jan 15 22:05:07 2022 -0500

    [mono] Disable partial generic sharing for gparams with non-enum constraints for method gparams too. (#63813)

    This is an optimization, but it also avoids hitting some gsharing limitations wrt
    calling abstract static methods from gshared code.

    Fixes https://github.com/dotnet/runtime/issues/60447.

commit c5c7967ddccc46c84c98c0e8c7e00c3009c65894
Author: Stephen Toub <stoub@microsoft.com>
Date:   Sat Jan 15 20:35:25 2022 -0500

    Unify string.{Last}IndexOfAny and span.{Last}IndexOfAny (#63817)

    * Unify string.{Last}IndexOfAny and span.{Last}IndexOfAny

    Currently, string.IndexOfAny delegates to span.IndexOfAny (MemoryExtensions) for 1 through 5 values, and for more than it, it falls back to its own "probabilistic map"-based implementation, which tries to avoid looping through each value character for each character in the input.  span.IndexOfAny doesn't do that, instead always looping through every char for every input char.  This PR moves the logic from string into MemoryExtensions and then has string unconditionally delegate to span.

    string.LastIndexOfAny in contrast would only delegate to span's implementation if the values list actually only had a single character in it; otherwise, it would again fall back to its own "probabilistic map"-based implementation.  This PR again moves that fallback into MemoryExtensions, with string unconditionally delegating to it.  MemoryExtensions also has LastIndexOf overloads for 2 and 3 items, so rather than using the probabilistic path for those, it delegates to the existing overloads.

    * Address PR feedback

commit 1e22b3f00501e8263af571ad74cb043fb3407b70
Author: Jeremy Koritzinsky <jekoritz@microsoft.com>
Date:   Sat Jan 15 12:59:33 2022 -0800

    Refactor the "produce an RSP file" step into a separate step from the "run ILC" step to make it easier to generate the RSP file on the fly (#63820)

commit fd2883f7bb60e75df6edcec58ac7bc79ecd10196
Author: Jan Kotas <jkotas@microsoft.com>
Date:   Sat Jan 15 12:21:07 2022 -0800

    Delete notifyexternals.* (#63835)

    Leftovers from loader lock MDA

commit 78dea7ff6599dd851210df6db330ee3b58f5294c
Author: Stephen Toub <stoub@microsoft.com>
Date:   Sat Jan 15 10:28:53 2022 -0500

    Add Regex FindFirstChar optimization for a literal after an atomic loop (#63477)

    * Add Regex FindFirstChar optimization for a literal after an atomic loop

    If after all of our analysis we can't find anything to IndexOf{Any} as part of finding the next match location, we'll also look for a literal (a single char, a string of chars, or a set of a small number of chars) following an unbounded atomic set loop that starts the pattern.  In that case, we can IndexOf for the literal, and then walk backwards through the characters prior to it looking for the beginning of the match.

    * Extend optimization to Setloop/lazy in addition to Setloopatomic

commit c30d55ec5b584e26186a85adedf313c81a64269c
Author: Tanner Gooding <tagoo@outlook.com>
Date:   Sat Jan 15 05:00:18 2022 -0800

    Perform some minor code cleanup of the System.Numerics and System.Runtime.Intrinsics namespaces (#63753)

    * Ensure the System.Numerics and System.Runtime.Intrinsics namespaces are using explicit type when "not apparent" to match repo conventions

    * Ensure the System.Runtime.Intrinsics types are using TARGET_64BIT to match project convention

    * Improving some docs and simplifying names where possible

commit a2e017dc876729678d7874706086bd444f010bcf
Author: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date:   Sat Jan 15 15:42:31 2022 +0300

    Fix MOffset size estimate (#63766)

commit 9db60963097adac1c25a5117d3918de17e1b5fb1
Author: Egor Bogatov <egorbo@gmail.com>
Date:   Sat Jan 15 15:20:36 2022 +0300

    JIT: Mark constant arguments of HWINTRINSIC nodes as DONT_CSE (#63442)

commit 20e6ec1a43cab03cd2d48f9fad32d56e83787ea0
Author: Geoff Kizer <geoffrek@microsoft.com>
Date:   Sat Jan 15 04:03:03 2022 -0800

    Avoid unnecessary string allocation in HttpRuleParser.GetHostLength (#63641)

    * avoid unnecessary string allocation in HttpRuleParser.GetHostLength

    Co-authored-by: Geoffrey Kizer <geoffrek@windows.microsoft.com>

commit 25d999b5a6711fc6d2ffc42fa38a58ec865a7232
Author: Stephen Toub <stoub@microsoft.com>
Date:   Sat Jan 15 06:50:49 2022 -0500

    Improve use of {Last}IndexOf{Any} in Regex loops (#63428)

    * Improve .*string to LastIndexOf "string" rather than just 's'

    * Enable .*string LastIndexOf optimization in the face of an UpdateBumpalong

    If the loop starts the expression, we will have inserted an UpdateBumpalong node, but that was then interfering with detecting a subsequent character/string.

    * Use IndexOf{Any} in lazy loop backtracking

    * Improve how sets are described in comments

    * Change RealWorld tests to be invoked once per engine

    To help with debugging

    * Address PR feedback

commit 386f87139c7fe48f6b733e3cae6d09128c827192
Author: Aleksey Kliger (λgeek) <alklig@microsoft.com>
Date:   Sat Jan 15 04:05:03 2022 -0500

    [metadata] Use MonoDefaults from components without hacks (#63822)

commit 692052e016407e6eb11feeaee5269625c3ee741a
Author: Ankit Jain <radical@gmail.com>
Date:   Fri Jan 14 23:52:13 2022 -0500

    Split `sendtohelixhelp.proj` to extract wasm, and mobile bits to separate files. (#63373)

    Extract wasm, and mobile specific bits from sendtohelixhelp.proj into  …
    .. separate files, so they can be easier to manage.

    - the platform specific properties are set in their respective files
      (for eg `sendtohelixhelp-wasm.proj`)
    - a new target `BuildHelixCommand` is extracted from
      `BuildHelixWorkItems`, which runs first
      - and essentially builds `@(HelixCommand)`

    - Platform specific targets can run via
      `$(BuildHelixWorkItemsDependsOn)`
      - which then add any "special" helix work items

    - `BuildHelixWorkItems` in the main file supports adding for the regular
      case, which is controlled by `$(EnableDefaultBuildHelixWorkItems)`.

    Also, fixes https://github.com/dotnet/runtime/issues/52137

commit 9daaab152ff1c0794ee21645bf57acf444f900ff
Author: Anton Firszov <Anton.Firszov@microsoft.com>
Date:   Sat Jan 15 03:15:26 2022 +0100

    serialize SendPacketsAsync tests (#63702)

commit 40047f2a82595546eadbabf9e438f7592eb1f002
Author: Stephen Toub <stoub@microsoft.com>
Date:   Fri Jan 14 20:48:36 2022 -0500

    Improve Regex UpdateBumpalong optimization for non-atomic and lazy loops (#63398)

    * Improve handling of UpdateBumpalong for non-atomic loops

    For atomic greedy loops, UpdateBumpalong is serving its purpose: upon consuming as much as possible for the loop, base.runtextpos is set to that position so that the next time FindFirstChar runs, it'll start from at least that location.  However, for non-atomic greedy loops, with base.runtextpos being set to the ending position after each backtracking, we end up inadvertently voiding any benefits of the UpdateBumpalong, as we end up overwriting the further position with the shorter position.  A simple tweak to that, only setting the position if it's greater, yields significant benefits, in particular when there's no match.

    * Add more tests for lazy loops

    These just duplicate the greedy loop tests and tweak them for lazy.

    * Insert UpdateBumpalong for lazy loops as well

    * Address PR feedback

commit 513fe2863ad5ec6dc453d223d4b60f787a0ffa78
Author: Tomáš Rylek <trylek@microsoft.com>
Date:   Sat Jan 15 00:36:58 2022 +0100

    More duplicate projects under JIT/Methodical/NaN to delete (#63771)

commit 2692407f03ce8b648c54daa4d3a3eb534132edc9
Author: Santiago Fernandez Madero <safern@microsoft.com>
Date:   Fri Jan 14 13:36:50 2022 -0800

    Build all packages on source-build even when in servicing (#63755)

commit e1c69cc75a4c51ea3e3011a084f74b486b2dbc88
Author: Tomáš Rylek <trylek@microsoft.com>
Date:   Fri Jan 14 21:47:44 2022 +0100

    Move localloc/common library under JIT folder (#63510)

    In today source tree we have five different libraries named
    'common'. This change is a first step in deduplicating their names;
    I have also moved the library under the JIT/ folder as it's
    used not only by JIT/jit64 tests but also by Methodical and
    Regression tests.

    Thanks

    Tomas

commit 3a83c5ca772a1a74e1707474c1d05c283f264a2f
Author: Jan Kotas <jkotas@microsoft.com>
Date:   Fri Jan 14 12:47:18 2022 -0800

    Delete unused method (#63797)

commit 02e22b02975d50944220e6e9a494af491487c6a9
Author: Tomáš Rylek <trylek@microsoft.com>
Date:   Fri Jan 14 21:00:01 2022 +0100

    Remove string[] args from Main methods under JIT/Methodical (#63770)

    In most cases the arguments were formal and not really used so
    I just fixed the Main method signature. In a bunch of cases the
    command-line arguments supported variant functionality of the
    test case but I haven't found any test projects that would be
    exercising this functionality. I don't think it makes sense to
    keep untested code paths so I deleted the logic pertaining to
    non-empty command-line arguments.

    In the particular case of stringintern tests, each test apparently
    had a TestSameObjRef and TestDiffObjRef variant, triggered by
    command-line arguments. I tried to run TestDiffObjRef but it
    ended up failing left and right - not suprising for untested
    code logic - so I also deleted the TestDiffObjRef variants
    as I suppose the invariants previously tested there no longer hold.

    Thanks

    Tomas

commit 562606671166edb60234c5062f69b35f6b2ac5c9
Author: Egor Chesakov <Egor.Chesakov@microsoft.com>
Date:   Fri Jan 14 10:44:07 2022 -0800

    Enable superpmi-collect pipeline on macOS arm64 (#63691)

    * Enable superpmi-collect on macOS Arm64 in eng/pipelines/coreclr/superpmi-collect.yml

    * Add -platform argument and use the value for determining what Helix queue to use in src/coreclr/scripts/superpmi_collect_setup.py

    * Pass platform to superpmi_collect_setup.py in eng/pipelines/coreclr/templates/run-superpmi-collect-job.yml

    * Copy *.dylib on macOS and *.so on Linux in src/coreclr/scripts/superpmi_collect_setup.py

    * Install azure-storage-blob in eng/pipelines/coreclr/templates/run-superpmi-collect-job.yml

    * Remove macOS/x64 from platforms list in eng/pipelines/coreclr/superpmi-collect.yml

    * Add "CoreCLR Product Build OSX x64 checked" that produces required artifacts that consumed by macOS/arm64 superpmi-collect-job

    * Fix typo in libraries_test_assets should correspond to target arch in eng/pipelines/coreclr/templates/superpmi-collect-job.yml

    * Update a comment indicating what Helix queues are used for macOS in src/coreclr/scripts/superpmi_collect_setup.py

    * Workaround https://github.com/dotnet/sdk/issues/23430 in src/coreclr/scripts/superpmi_benchmarks.py

    * Enable macOS/arm64 benchmarks collection in eng/pipelines/coreclr/superpmi-collect.yml

commit a991e1349e4325770d8e2ddf085184a68cd2555b
Author: Elinor Fung <elfung@microsoft.com>
Date:   Fri Jan 14 10:49:26 2022 -0500

    Make ObjectiveC tests in System.Runtime.InteropServices.Tests check exit code for remote execution (#63769)

commit 33179fa0ac1ab75bb09e5cc7ed63aa6629c51411
Author: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date:   Fri Jan 14 17:49:06 2022 +0200

    [Group 5] Enable nullable annotations for `Microsoft.Extensions.Configuration.Ini` (#60368)

    * Add annotations

    * Use pattern matching

    * NetCoreAppMinimum

    * ReadLine won't return null

    * Update src/libraries/Microsoft.Extensions.Configuration.Ini/ref/Microsoft.Extensions.Configuration.Ini.csproj

    Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

    * Add comment

    * Revert non-nullable change

    Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

commit 3956126d55e32203a8926a54a8ee3090b3e69749
Author: MSDN.WhiteKnight <35516665+MSDN-WhiteKnight@users.noreply.github.com>
Date:   Fri Jan 14 20:33:03 2022 +0500

    Fix typo in  SRM package description (#63782)

commit d568a3fec2c9a2e7341466a28f88f52558fddf6c
Author: Tarek Mahmoud Sayed <tarekms@microsoft.com>
Date:   Fri Jan 14 07:27:32 2022 -0800

    Introduce Activity.IsStopped Property (#63713)

    Co-authored-by: Dan Moseley <danmose@microsoft.com>

commit 0b527a201f4c286f13ef8b829bbd1651bdad7a52
Author: Zoltan Varga <vargaz@gmail.com>
Date:   Fri Jan 14 08:07:47 2022 -0500

    Fix a style issue. (#63776)

commit b184ee0393aaf0395a69e70590d5c529e8c93ccf
Author: Adam Sitnik <adam.sitnik@gmail.com>
Date:   Fri Jan 14 10:04:11 2022 +0100

    MemoryMappedFile: don't check for file existence if there is no need (#63754)

    Co-authored-by: Stephen Toub <stoub@microsoft.com>

commit c96869a6d10a235b5a26c9e15d685fabc7f87cb0
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Fri Jan 14 17:03:22 2022 +0900

    Disable annoying warnings in the repro project (#63777)

    We have repo-wide WarnAsError that makes this super annoying in a repro project.

commit b7e0a85ab6111b77ad19a1c2db0dedcedded4940
Author: Qiao <35673267+shushanhf@users.noreply.github.com>
Date:   Fri Jan 14 14:33:20 2022 +0800

    [LoongArch64] add all the coreclr-build-config files (#62889)

commit 1ba80f698c85b525545f1a13c02eb405588b0461
Author: Andrii Kurdiumov <kant2002@gmail.com>
Date:   Fri Jan 14 12:20:45 2022 +0600

    Remove errors during first run of runpaltests.h (#62642)

    * Remove errors during first run of runpaltests.h

    If you run `runpaltests.h` for first time, you will see 2 errors about file or folder not found.

    First error comes from using `RELATIVE_PATH_TO_PAL_TESTS` which does not used anywhere, except maybe some platform where you can `cd` to non-existing folder. In that case 3rd parameter to script would be interpreted incorrectly. I doubt that, but who know what's somewhere deep in infra.

    Second error is entirely preventable, since `cd $PAL_TEST_OUTPUT_DIR` does not affect anything until subsequent `cd $PAL_TEST_OUTPUT_DIR` on line 118.

    Discovered here https://github.com/dotnet/runtime/pull/62625#issuecomment-991172978

    * Remove not nescessary cd

    * Fix

    * oopsie

commit 27fdc2d22f8717c7b0ba254ae9ef2900d00f5e7a
Author: Stephen Halter <halter73@gmail.com>
Date:   Thu Jan 13 17:20:28 2022 -0800

    Avoid deadlock with ConfigurationManager (#62209)

    Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

commit 2c28e63f9360280011a3b03c1ca6dc0edce1fae4
Author: Alexander Köplinger <alex.koeplinger@outlook.com>
Date:   Thu Jan 13 22:17:54 2022 +0100

    Temporarily disable coredumps during library testing on macOS (#63742)

    System.Runtime.InteropServices.Tests seems to produce >10GB of coredumps which overwhelms CI.

commit 79e40e35ce3e218ad2d81259572e462b56bfd807
Author: Kevin Jones <kevin@vcsjones.com>
Date:   Thu Jan 13 15:04:36 2022 -0500

    Add public constants for HMAC and hash sizes

commit c912a1532a1bb653a21a3749aaad7c5fb556ae01
Author: Kevin Jones <kevin@vcsjones.com>
Date:   Thu Jan 13 14:07:55 2022 -0500

    Change non-breaking spaces (U00A0) to a plain space in code files (#63688)

commit ec0c7f3a91b9fc47f7a867f0b997ba34560302e7
Author: Aaron Robinson <arobins@microsoft.com>
Date:   Thu Jan 13 12:20:43 2022 -0500

    Add negative tests for by-ref in UnmanagedCallersOnly scenarios. (#63711)

commit c78d9fa3edb2ae8e14f0529566c20d33a2512cab
Author: Maxim Lipnin <v-maxlip@microsoft.com>
Date:   Thu Jan 13 19:08:27 2022 +0300

    Disable System.Drawing.Common.Tests test suite on Windows+Mono (#63726)

commit 048e1a395523f1855c054d01a3f1f4c55d873ea4
Author: Simon Rozsival <simon@rozsival.com>
Date:   Thu Jan 13 16:57:12 2022 +0100

    [Android] Throw PNSE for unavailable network information (#63633)

    * Update tests

    * Add android specific implementation

    * Add UnsupportedOSPlatform attributes

    * Fix typo

    * Remove unnecessary file reference

    * Clean-up code

    * Minor code clean-up

    * Remove dictionary

    * Refactoring

    * Revert comment change

commit 77bdad50a01f3a330c03b093544245d39620314b
Author: Alexander Köplinger <alex.koeplinger@outlook.com>
Date:   Thu Jan 13 16:06:39 2022 +0100

    Bump to macOS 10.14 minimum in libs and mono builds too (#63682)

    https://github.com/dotnet/runtime/pull/62822 bumped the minimum CMAKE_OSX_DEPLOYMENT_TARGET to 10.14, but the libs.native and mono parts of the build still used the old 10.13 value.
    In build-native.sh for libs.native we can actually remove the explicit setting since we're already setting it in eng/native/configurecompiler.cmake.

commit 01cdd1dcaebcc9f2ab36027204142a6703a1b70b
Author: Pavel Savara <pavelsavara@microsoft.com>
Date:   Thu Jan 13 15:42:08 2022 +0100

    [wasm] Emscripten uses `require` even when targeting ES6. This deals with the consequences. (#63718)

commit a13ee96335ea4c41cfe273855611caec4c35cae8
Author: Thays Grazia <thaystg@gmail.com>
Date:   Thu Jan 13 09:53:43 2022 -0300

    [wasm][debugger] Fixing error after receiving loaded_files = null (#63591)

    * Fixing #39301

    * Addressing @radical comments

    * Sending the error toconsole in the browser.

    * Applying @radical suggestion.

    * Update src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs

    Co-authored-by: Ankit Jain <radical@gmail.com>

    * Update src/mono/wasm/debugger/tests/debugger-test/wasm-page-without-assets.html

    Co-authored-by: Ankit Jain <radical@gmail.com>

    * Space -> tabs

    * Fix compilation error.

    Co-authored-by: Ankit Jain <radical@gmail.com>

commit 64c05a3bcb4e71ee9972a3fb47eb4d3e061d3462
Author: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date:   Thu Jan 13 12:58:37 2022 +0300

    Reconfigure the field sequences for statics (#62632)

    * Reconfigure the field sequences for statics

    To make the "boxed static" and, in the future, "shared" cases identical
    to simple ones.

    It used to be that we attached the field sequence to the
    "inner" constant, and then added the "#FirstElem" pseudo-field for the
    outer offset. This was causing complexity and mistakes in the pattern
    matching performed by "IsFieldAddr".

    The solution is straightforward: always use the outer offset for the sequence.
    The much simpler pattern is easier and cheaper to recognize, with less room for
    false positives.

    * Drop support for mutable RVA statics

    They were broken on 32 bit already, and this change does not
    break them on 64 bit, but we'll reserve the right to do that
    in the future as the scenario appears to be non-existent.

commit 46db4aa3c505ac36cf8d0d612d4161bb7239ed87
Author: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
Date:   Thu Jan 13 15:28:38 2022 +0900

    Add NativeAOT libraries tests annotations (#63668)

    Adds `ActiveIssue`/`Conditional` attributes to libraries tests so that we can get a clean run with NativeAOT.

    Starting with System.Collections, System.Runtime, and System.IO.FileSystem.

commit f580068aa93fb3c6d5fbc7e33f6cd7d52fa86b24
Author: Dmitry Bogatykh <bogatykh@gmail.com>
Date:   Thu Jan 13 07:00:39 2022 +0300

    Fix JsonObject constuctor (#63150)

    * Fix JsonObject constuctor

    * Fix constructor this

    * JsonObject constructor test

    * Augment tests

    Co-authored-by: Layomi Akinrinade <layomia@gmail.com>

commit c7630198c93988fcf2cab2e6e30aadc76328e09a
Author: Pavel Savara <pavelsavara@microsoft.com>
Date:   Thu Jan 13 02:55:18 2022 +0100

    [wasm] Load assets earlier (#63623)

    - allow Module.config to have assets with buffer instead of url
    - change sample to show how emscripten callbacks are triggered
    - pass config into onConfigLoaded and made it async
    - split asset download from copying it into memory
    - moved startup s…

* #51371 added pipeName case for running on macos

* #51371 removed extra spaces, adjusted IsCaseSensitiveProperty and other review comments changes

* #51371 removed extra spaces

* #51371 removed pipePath change in windows file

* #51371 Done minor changes

* #51371 extended maxdirectory for not windows

* #51371 in case of windows don't change parameter IsCaseSensitiveOS

* #51371 changing maxdirectory for nonwindows

* #51371 removed from Pipestream the change and edited path in FileCleanupTestBase.cs
---
 .../System/IO/StreamConformanceTests.cs       | 25 -------------------
 .../System/IO/FileCleanupTestBase.cs          |  5 ++++
 .../TestUtilities/System/PlatformDetection.cs |  8 +++++-
 .../tests/Base/FileGetSetAttributes.cs        |  3 +--
 .../tests/Directory/CreateDirectory.cs        |  1 -
 .../tests/Directory/Exists.cs                 |  1 -
 .../Directory/GetFileSystemEntries_str_str.cs |  4 +--
 .../tests/Directory/GetFiles.cs               |  7 +++---
 .../System.IO.FileSystem/tests/File/Create.cs |  4 +--
 .../System.IO.FileSystem/tests/File/Exists.cs |  2 --
 .../tests/PortedCommon/IOInputs.cs            |  2 +-
 11 files changed, 19 insertions(+), 43 deletions(-)

diff --git a/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs b/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
index 7dc9519665c588..792e5387fd04aa 100644
--- a/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
+++ b/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
@@ -711,7 +711,6 @@ public abstract class StandaloneStreamConformanceTests : StreamConformanceTests
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ArgumentValidation_ThrowsExpectedException()
         {
             await foreach (Stream? stream in GetStreamsForValidation())
@@ -725,7 +724,6 @@ public virtual async Task ArgumentValidation_ThrowsExpectedException()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Disposed_ThrowsObjectDisposedException()
         {
             await foreach (Stream? stream in GetStreamsForValidation())
@@ -815,7 +813,6 @@ public virtual async Task Read_DataStoredAtDesiredOffset(ReadWriteMode mode)
         [InlineData(ReadWriteMode.SyncArray)]
         [InlineData(ReadWriteMode.AsyncArray)]
         [InlineData(ReadWriteMode.AsyncAPM)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Write_DataReadFromDesiredOffset(ReadWriteMode mode)
         {
             using Stream? stream = await CreateReadWriteStream();
@@ -1599,7 +1596,6 @@ protected static bool Bidirectional(StreamPair streams) =>
             streams.Stream2.CanRead && streams.Stream2.CanWrite;
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ArgumentValidation_ThrowsExpectedException()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1611,7 +1607,6 @@ public virtual async Task ArgumentValidation_ThrowsExpectedException()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Disposed_ThrowsObjectDisposedException()
         {
             StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1624,7 +1619,6 @@ public virtual async Task Disposed_ThrowsObjectDisposedException()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadWriteAsync_PrecanceledOperations_ThrowsCancellationException()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1636,7 +1630,6 @@ public virtual async Task ReadWriteAsync_PrecanceledOperations_ThrowsCancellatio
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadAsync_CancelPendingTask_ThrowsCancellationException()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1646,7 +1639,6 @@ public virtual async Task ReadAsync_CancelPendingTask_ThrowsCancellationExceptio
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadAsync_CancelPendingValueTask_ThrowsCancellationException()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1656,7 +1648,6 @@ public virtual async Task ReadAsync_CancelPendingValueTask_ThrowsCancellationExc
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadWriteByte_Success()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1729,7 +1720,6 @@ public virtual async Task ReadWrite_Success_Large(ReadWriteMode mode, int writeS
 
         [Theory]
         [MemberData(nameof(ReadWrite_Success_MemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadWrite_Success(ReadWriteMode mode, int writeSize, bool startWithFlush)
         {
             foreach (CancellationToken nonCanceledToken in new[] { CancellationToken.None, new CancellationTokenSource().Token })
@@ -1786,7 +1776,6 @@ public virtual async Task ReadWrite_Success(ReadWriteMode mode, int writeSize, b
 
         [Theory]
         [MemberData(nameof(ReadWrite_Modes))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadWrite_MessagesSmallerThanReadBuffer_Success(ReadWriteMode mode)
         {
             if (!FlushGuaranteesAllDataWritten)
@@ -1835,7 +1824,6 @@ public virtual async Task ReadWrite_MessagesSmallerThanReadBuffer_Success(ReadWr
         [Theory]
         [MemberData(nameof(AllReadWriteModesAndValue), false)]
         [MemberData(nameof(AllReadWriteModesAndValue), true)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Read_Eof_Returns0(ReadWriteMode mode, bool dataAvailableFirst)
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1874,7 +1862,6 @@ public virtual async Task Read_Eof_Returns0(ReadWriteMode mode, bool dataAvailab
         [InlineData(ReadWriteMode.SyncArray)]
         [InlineData(ReadWriteMode.AsyncArray)]
         [InlineData(ReadWriteMode.AsyncAPM)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Read_DataStoredAtDesiredOffset(ReadWriteMode mode)
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -1904,7 +1891,6 @@ public virtual async Task Read_DataStoredAtDesiredOffset(ReadWriteMode mode)
         [InlineData(ReadWriteMode.SyncArray)]
         [InlineData(ReadWriteMode.AsyncArray)]
         [InlineData(ReadWriteMode.AsyncAPM)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Write_DataReadFromDesiredOffset(ReadWriteMode mode)
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2003,7 +1989,6 @@ public static IEnumerable<object[]> ReadAsync_ContinuesOnCurrentContextIfDesired
 
         [Theory]
         [MemberData(nameof(ReadAsync_ContinuesOnCurrentContextIfDesired_MemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadAsync_ContinuesOnCurrentSynchronizationContextIfDesired(bool flowExecutionContext, bool? continueOnCapturedContext)
         {
             await default(JumpToThreadPoolAwaiter); // escape xunit sync ctx
@@ -2086,7 +2071,6 @@ public virtual async Task ReadAsync_ContinuesOnCurrentSynchronizationContextIfDe
 
         [Theory]
         [MemberData(nameof(ReadAsync_ContinuesOnCurrentContextIfDesired_MemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadAsync_ContinuesOnCurrentTaskSchedulerIfDesired(bool flowExecutionContext, bool? continueOnCapturedContext)
         {
             await default(JumpToThreadPoolAwaiter); // escape xunit sync ctx
@@ -2176,7 +2160,6 @@ await Task.Factory.StartNew(() =>
         [InlineData(ReadWriteMode.AsyncMemory)]
         [InlineData(ReadWriteMode.SyncAPM)]
         [InlineData(ReadWriteMode.AsyncAPM)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ZeroByteRead_BlocksUntilDataAvailableOrNops(ReadWriteMode mode)
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2243,7 +2226,6 @@ public virtual async Task ZeroByteRead_BlocksUntilDataAvailableOrNops(ReadWriteM
         [InlineData(ReadWriteMode.AsyncMemory)]
         [InlineData(ReadWriteMode.SyncAPM)]
         [InlineData(ReadWriteMode.AsyncAPM)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ZeroByteWrite_OtherDataReceivedSuccessfully(ReadWriteMode mode)
         {
             byte[][] buffers = new[] { Array.Empty<byte>(), Encoding.UTF8.GetBytes("hello"), Array.Empty<byte>(), Encoding.UTF8.GetBytes("world") };
@@ -2297,7 +2279,6 @@ public virtual async Task ZeroByteWrite_OtherDataReceivedSuccessfully(ReadWriteM
         [Theory]
         [InlineData(false)]
         [InlineData(true)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadWrite_CustomMemoryManager_Success(bool useAsync)
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2418,7 +2399,6 @@ public virtual async Task CopyToAsync_AllDataCopied_Large(bool useAsync) =>
 
         [Theory]
         [MemberData(nameof(CopyToAsync_AllDataCopied_MemberData))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task CopyToAsync_AllDataCopied(int byteCount, bool useAsync)
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2456,7 +2436,6 @@ await Task.WhenAll(Enumerable.Range(0, 20).Select(_ => Task.Run(async () =>
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Timeout_Roundtrips()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2491,7 +2470,6 @@ public virtual async Task Timeout_Roundtrips()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task ReadTimeout_Expires_Throws()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2626,7 +2604,6 @@ public virtual async Task ReadAsync_DuringReadAsync_ThrowsIfUnsupported()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Flush_ValidOnWriteableStreamWithNoData_Success()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2641,7 +2618,6 @@ public virtual async Task Flush_ValidOnWriteableStreamWithNoData_Success()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Flush_ValidOnReadableStream_Success()
         {
             using StreamPair streams = await CreateConnectedStreamsAsync();
@@ -2659,7 +2635,6 @@ public virtual async Task Flush_ValidOnReadableStream_Success()
         [InlineData(0)]
         [InlineData(1)]
         [InlineData(2)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public virtual async Task Dispose_ClosesStream(int disposeMode)
         {
             if (!CansReturnFalseAfterDispose)
diff --git a/src/libraries/Common/tests/TestUtilities/System/IO/FileCleanupTestBase.cs b/src/libraries/Common/tests/TestUtilities/System/IO/FileCleanupTestBase.cs
index bc53138d8be13a..8f14f24f97f933 100644
--- a/src/libraries/Common/tests/TestUtilities/System/IO/FileCleanupTestBase.cs
+++ b/src/libraries/Common/tests/TestUtilities/System/IO/FileCleanupTestBase.cs
@@ -147,6 +147,11 @@ protected static string GetNamedPipeServerStreamName()
                 return Guid.NewGuid().ToString("N");
             }
 
+            if (!PlatformDetection.IsCaseSensitiveOS)
+            {
+                return $"/tmp/{Guid.NewGuid().ToString("N")}";
+            }
+
             const int MinUdsPathLength = 104; // required min is 92, but every platform we currently target is at least 104
             const int MinAvailableForSufficientRandomness = 5; // we want enough randomness in the name to avoid conflicts between concurrent tests
             string prefix = Path.Combine(Path.GetTempPath(), "CoreFxPipe_");
diff --git a/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs b/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
index 1cbd9c19f69155..857783a9e95c20 100644
--- a/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
+++ b/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
@@ -60,8 +60,14 @@ public static partial class PlatformDetection
         public static bool IsNotWindows => !IsWindows;
 
         public static bool IsCaseInsensitiveOS => IsWindows || IsOSX || IsMacCatalyst;
-        public static bool IsCaseSensitiveOS => !IsCaseInsensitiveOS;
 
+#if NETCOREAPP
+        public static bool IsCaseSensitiveOS => !IsCaseInsensitiveOS && !RuntimeInformation.RuntimeIdentifier.StartsWith("iossimulator")
+                                                                     && !RuntimeInformation.RuntimeIdentifier.StartsWith("tvossimulator");
+#else
+        public static bool IsCaseSensitiveOS => !IsCaseInsensitiveOS;
+#endif
+        
         public static bool IsThreadingSupported => !IsBrowser;
         public static bool IsBinaryFormatterSupported => IsNotMobile && !IsNativeAot;
         public static bool IsSymLinkSupported => !IsiOS && !IstvOS;
diff --git a/src/libraries/System.IO.FileSystem/tests/Base/FileGetSetAttributes.cs b/src/libraries/System.IO.FileSystem/tests/Base/FileGetSetAttributes.cs
index 2c01cd430d32f3..18fc5106f9be70 100644
--- a/src/libraries/System.IO.FileSystem/tests/Base/FileGetSetAttributes.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Base/FileGetSetAttributes.cs
@@ -62,10 +62,9 @@ public void SettingInvalidAttributes_Unix(FileAttributes attributes)
             AssertSettingInvalidAttributes(path, attributes);
         }
 
-        [Theory]
+        [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseSensitiveOS))]
         [InlineData(FileAttributes.Hidden)]
         [PlatformSpecific(TestPlatforms.AnyUnix & ~(TestPlatforms.OSX | TestPlatforms.FreeBSD))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public void SettingInvalidAttributes_UnixExceptOSXAndFreeBSD(FileAttributes attributes)
         {
             string path = CreateItem();
diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs b/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs
index 4e53a93a4e03a9..af0c040223675d 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/CreateDirectory.cs
@@ -201,7 +201,6 @@ public void AllowedSymbols()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public void DirectoryEqualToMaxDirectory_CanBeCreatedAllAtOnce()
         {
             DirectoryInfo testDir = Create(GetTestFilePath());
diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs b/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs
index a05fe8ad41f7dc..9e3e21978eb138 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs
@@ -302,7 +302,6 @@ public void PathWithReservedDeviceNameAsPath_ReturnsFalse(string component)
         [ActiveIssue("https://github.com/dotnet/runtimelab/issues/901", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
         [Theory,
             MemberData(nameof(UncPathsWithoutShareName))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public void UncPathWithoutShareNameAsPath_ReturnsFalse(string component)
         {
             Assert.False(Exists(component));
diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs b/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs
index c4858914a43812..e439db9369f42d 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs
@@ -697,9 +697,7 @@ public void WindowsSearchPatternWhitespace()
             Assert.Empty(GetEntries(TestDirectory, "\t"));
         }
 
-        [Fact]
-        [PlatformSpecific(CaseSensitivePlatforms)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseSensitiveOS))]
         public void SearchPatternCaseSensitive()
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/GetFiles.cs b/src/libraries/System.IO.FileSystem/tests/Directory/GetFiles.cs
index e3b7a529a774f8..f214f08899bcd1 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/GetFiles.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/GetFiles.cs
@@ -42,14 +42,13 @@ public void EnumerateWithSymLinkToFile()
         }
 
         [ConditionalFact(nameof(AreAllLongPathsAvailable))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public void EnumerateFilesOverLegacyMaxPath()
         {
             // We want to test that directories under the legacy MAX_PATH (260 characters, including the null) can iterate files
             // even if the full path is over 260.
-
-            string directory = IOServices.GetPath(GetTestFilePath(), 250);
-            Assert.Equal(250, directory.Length);
+            var length = OperatingSystem.IsWindows() ? 250 : 258;
+            string directory = IOServices.GetPath(GetTestFilePath(), length);
+            Assert.Equal(length, directory.Length);
             Assert.True(Directory.CreateDirectory(directory).Exists);
 
             for (int i = 0; i < 6; i++)
diff --git a/src/libraries/System.IO.FileSystem/tests/File/Create.cs b/src/libraries/System.IO.FileSystem/tests/File/Create.cs
index fb7f4be892c74b..69e9042ae1b548 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/Create.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/Create.cs
@@ -217,9 +217,7 @@ public void LongFileName()
             Assert.False(File.Exists(path));
         }
 
-        [Fact]
-        [PlatformSpecific(CaseSensitivePlatforms)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseSensitiveOS))]
         public void CaseSensitive()
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
diff --git a/src/libraries/System.IO.FileSystem/tests/File/Exists.cs b/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
index d35ba99eeb2ab5..811df24f9e741f 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
@@ -112,7 +112,6 @@ public void PathAlreadyExistsAsDirectory()
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public void DirectoryLongerThanMaxDirectoryAsPath_DoesntThrow()
         {
             Assert.All((IOInputs.GetPathsLongerThanMaxDirectory(GetTestFilePath())), (path) =>
@@ -234,7 +233,6 @@ public void PathWithReservedDeviceNameAsPath_ReturnsFalse(string component)
         [ActiveIssue("https://github.com/dotnet/runtimelab/issues/901", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
         [Theory,
             MemberData(nameof(UncPathsWithoutShareName))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/51371", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)]
         public void UncPathWithoutShareNameAsPath_ReturnsFalse(string component)
         {
             Assert.False(Exists(component));
diff --git a/src/libraries/System.IO.FileSystem/tests/PortedCommon/IOInputs.cs b/src/libraries/System.IO.FileSystem/tests/PortedCommon/IOInputs.cs
index 677a027a732ea3..7187dc7339c9a6 100644
--- a/src/libraries/System.IO.FileSystem/tests/PortedCommon/IOInputs.cs
+++ b/src/libraries/System.IO.FileSystem/tests/PortedCommon/IOInputs.cs
@@ -23,7 +23,7 @@ internal static class IOInputs
     // Windows specific, this is the maximum length that can be passed to APIs taking directory names, such as Directory.CreateDirectory & Directory.Move.
     // Does not include the trailing \0.
     // We now do the appropriate wrapping to allow creating longer directories. Like MaxPath, this is a legacy restriction.
-    public static readonly int MaxDirectory = 247;
+    public static readonly int MaxDirectory = OperatingSystem.IsWindows() ? 247 : 258;
 
     public const int MaxComponent = 255;
 

From 3e4c4a4c2c3343ac545bf48b9c3189556bfecf73 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 27 Jan 2022 08:44:11 -0500
Subject: [PATCH 108/161] Clean up RegexCode opcodes and debug-only tracing
 (#64346)

* Clean up RegexCode opcodes and debug-only tracing

No functional changes (other than deleting some useless debug-only tracing).  Cleans up RegexCode's const int opcodes by moving them into a dedicated enum, and cleans up some unused debugging-related code.  We may want to remove even more, but I at least wanted to get rid of RegexOptions.Debug so that we didn't have the extra option littered throughout the code.

* Address PR feedback
---
 .../gen/RegexGenerator.Emitter.cs             |   6 +-
 .../gen/RegexGenerator.Parser.cs              |  17 +-
 ...m.Text.RegularExpressions.Generator.csproj |   1 +
 .../src/System.Text.RegularExpressions.csproj |   1 +
 .../System/Text/RegularExpressions/Match.cs   |  45 +-
 .../Text/RegularExpressions/Regex.Debug.cs    |  12 +-
 .../System/Text/RegularExpressions/Regex.cs   |  21 +-
 .../Text/RegularExpressions/RegexCharClass.cs |  14 +-
 .../Text/RegularExpressions/RegexCode.cs      | 498 ++++++------------
 .../Text/RegularExpressions/RegexCompiler.cs  |   4 +-
 .../RegularExpressions/RegexInterpreter.cs    | 191 ++++---
 .../Text/RegularExpressions/RegexNode.cs      |  77 ++-
 .../Text/RegularExpressions/RegexNodeKind.cs  |  54 +-
 .../Text/RegularExpressions/RegexOpcode.cs    | 162 ++++++
 .../Text/RegularExpressions/RegexOptions.cs   |  11 +-
 .../Text/RegularExpressions/RegexParser.cs    |  21 +-
 .../Text/RegularExpressions/RegexRunner.cs    | 160 +++---
 .../Text/RegularExpressions/RegexTree.cs      |  16 +-
 .../Text/RegularExpressions/RegexWriter.cs    | 123 ++---
 19 files changed, 649 insertions(+), 785 deletions(-)
 create mode 100644 src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOpcode.cs

diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
index af4f27b59151fb..1f2a5d7de00a03 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
+++ b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
@@ -3353,9 +3353,9 @@ private static bool EmitInitializeCultureForGoIfNecessary(IndentedTextWriter wri
                 if (!needsCulture)
                 {
                     int[] codes = rm.Code.Codes;
-                    for (int codepos = 0; codepos < codes.Length; codepos += RegexCode.OpcodeSize(codes[codepos]))
+                    for (int codepos = 0; codepos < codes.Length; codepos += RegexCode.OpcodeSize((RegexOpcode)codes[codepos]))
                     {
-                        if ((codes[codepos] & RegexCode.Ci) == RegexCode.Ci)
+                        if (((RegexOpcode)codes[codepos] & RegexOpcode.CaseInsensitive) == RegexOpcode.CaseInsensitive)
                         {
                             needsCulture = true;
                             break;
@@ -3710,7 +3710,7 @@ private static string DescribeSet(string charClass) =>
                 RegexCharClass.NotWordClass => "any character other than a word character",
                 RegexCharClass.SpaceClass => "a whitespace character",
                 RegexCharClass.WordClass => "a word character",
-                _ => $"a character in the set {RegexCharClass.SetDescription(charClass)}",
+                _ => $"a character in the set {RegexCharClass.DescribeSet(charClass)}",
             };
 
         /// <summary>Writes a textual description of the node tree fit for rending in source.</summary>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Parser.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Parser.cs
index f5651fdf169c18..a7ba253ee2c929 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Parser.cs
+++ b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Parser.cs
@@ -150,19 +150,16 @@ private static bool IsSyntaxTargetForGeneration(SyntaxNode node) =>
 
             // Validate the options
             const RegexOptions SupportedOptions =
-                RegexOptions.IgnoreCase |
-                RegexOptions.Multiline |
-                RegexOptions.ExplicitCapture |
                 RegexOptions.Compiled |
-                RegexOptions.Singleline |
+                RegexOptions.CultureInvariant |
+                RegexOptions.ECMAScript |
+                RegexOptions.ExplicitCapture |
+                RegexOptions.IgnoreCase |
                 RegexOptions.IgnorePatternWhitespace |
+                RegexOptions.Multiline |
+                RegexOptions.NonBacktracking |
                 RegexOptions.RightToLeft |
-#if DEBUG
-                RegexOptions.Debug |
-#endif
-                RegexOptions.ECMAScript |
-                RegexOptions.CultureInvariant |
-                RegexOptions.NonBacktracking;
+                RegexOptions.Singleline;
             if ((regexOptions & ~SupportedOptions) != 0)
             {
                 return Diagnostic.Create(DiagnosticDescriptors.InvalidRegexArguments, methodSyntax.GetLocation(), "options");
diff --git a/src/libraries/System.Text.RegularExpressions/gen/System.Text.RegularExpressions.Generator.csproj b/src/libraries/System.Text.RegularExpressions/gen/System.Text.RegularExpressions.Generator.csproj
index 8f24e872e22660..e6982a3b83ce0e 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/System.Text.RegularExpressions.Generator.csproj
+++ b/src/libraries/System.Text.RegularExpressions/gen/System.Text.RegularExpressions.Generator.csproj
@@ -36,6 +36,7 @@
     <Compile Include="..\src\System\Text\RegularExpressions\RegexFindOptimizations.cs" Link="Production\RegexFindOptimizations.cs" />
     <Compile Include="..\src\System\Text\RegularExpressions\RegexNode.cs" Link="Production\RegexNode.cs" />
     <Compile Include="..\src\System\Text\RegularExpressions\RegexNodeKind.cs" Link="Production\RegexNodeKind.cs" />
+    <Compile Include="..\src\System\Text\RegularExpressions\RegexOpcode.cs" Link="Production\RegexOpcode.cs" />
     <Compile Include="..\src\System\Text\RegularExpressions\RegexOptions.cs" Link="Production\RegexOptions.cs" />
     <Compile Include="..\src\System\Text\RegularExpressions\RegexParseError.cs" Link="Production\RegexParseError.cs" />
     <Compile Include="..\src\System\Text\RegularExpressions\RegexParseException.cs" Link="Production\RegexParseException.cs" />
diff --git a/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj b/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj
index cfe2c82d38d1a5..0034d373563a96 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj
+++ b/src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj
@@ -34,6 +34,7 @@
     <Compile Include="System\Text\RegularExpressions\RegexMatchTimeoutException.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexNode.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexNodeKind.cs" />
+    <Compile Include="System\Text\RegularExpressions\RegexOpcode.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexOptions.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexParseError.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexParseException.cs" />
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs
index b941d1ad8d7a2f..3c67526b40e184 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Match.cs
@@ -329,31 +329,6 @@ private void TidyBalancing()
 
             _balancing = false;
         }
-
-#if DEBUG
-        [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        internal bool IsDebug => _regex != null && _regex.IsDebug;
-
-        internal virtual void Dump()
-        {
-            for (int i = 0; i < _matchcount.Length; i++)
-            {
-                Debug.WriteLine($"Capnum {i}:");
-
-                for (int j = 0; j < _matchcount[i]; j++)
-                {
-                    string text = "";
-
-                    if (_matches[i][j * 2] >= 0)
-                    {
-                        text = Text.Substring(_matches[i][j * 2], _matches[i][j * 2 + 1]);
-                    }
-
-                    Debug.WriteLine($"  ({_matches[i][j * 2]},{_matches[i][j * 2 + 1]}) {text}");
-                }
-            }
-        }
-#endif
     }
 
     /// <summary>
@@ -361,8 +336,7 @@ internal virtual void Dump()
     /// </summary>
     internal sealed class MatchSparse : Match
     {
-        // the lookup hashtable
-        internal new readonly Hashtable _caps;
+        private new readonly Hashtable _caps;
 
         internal MatchSparse(Regex regex, Hashtable caps, int capcount, string text, int begpos, int len, int startpos) :
             base(regex, capcount, text, begpos, len, startpos)
@@ -371,22 +345,5 @@ internal MatchSparse(Regex regex, Hashtable caps, int capcount, string text, int
         }
 
         public override GroupCollection Groups => _groupcoll ??= new GroupCollection(this, _caps);
-
-#if DEBUG
-        [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        internal override void Dump()
-        {
-            if (_caps != null)
-            {
-                foreach (object? entry in _caps)
-                {
-                    DictionaryEntry kvp = (DictionaryEntry)entry!;
-                    Debug.WriteLine($"Slot {kvp.Key} -> {kvp.Value}");
-                }
-            }
-
-            base.Dump();
-        }
-#endif
     }
 }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Debug.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Debug.cs
index 862af1731d3241..ee124fdf205c12 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Debug.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Debug.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 #if DEBUG
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Text.RegularExpressions.Symbolic;
@@ -11,16 +12,17 @@ namespace System.Text.RegularExpressions
 {
     public partial class Regex
     {
-        /// <summary>True if the regex has debugging enabled.</summary>
+        /// <summary>True if debug tracing should be enabled, only in debug builds.</summary>
         [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        internal bool IsDebug
+        internal static bool EnableDebugTracing
         {
             // These members aren't used from IsDebug, but we want to keep them in debug builds for now,
-            // so this is a convient place to include them rather than needing a debug-only illink file.
+            // so this is a convenient place to include them rather than needing a debug-only illink file.
             [DynamicDependency(nameof(SaveDGML))]
             [DynamicDependency(nameof(GenerateUnicodeTables))]
             [DynamicDependency(nameof(GenerateRandomMembers))]
-            get => (roptions & RegexOptions.Debug) != 0;
+            get;
+            set;
         }
 
         /// <summary>Unwind the regex and save the resulting state graph in DGML</summary>
@@ -62,7 +64,7 @@ internal static void GenerateUnicodeTables(string path)
         /// <param name="negative">if true then generate inputs that do not match</param>
         /// <returns></returns>
         [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        internal Collections.Generic.IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative)
+        internal IEnumerable<string> GenerateRandomMembers(int k, int randomseed, bool negative)
         {
             if (factory is not SymbolicRegexRunnerFactory srmFactory)
             {
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.cs
index 08793ce85ca68c..d07f3440de4b8a 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.cs
@@ -110,13 +110,6 @@ private void Init(string pattern, RegexOptions options, TimeSpan matchTimeout, C
             internalMatchTimeout = matchTimeout;
             roptions = options;
 
-#if DEBUG
-            if (IsDebug)
-            {
-                Debug.WriteLine($"Pattern: {pattern}    Options: {options & ~RegexOptions.Debug}    Timeout: {(matchTimeout == InfiniteMatchTimeout ? "infinite" : matchTimeout.ToString())}");
-            }
-#endif
-
             // Parse the input
             RegexTree tree = RegexParser.Parse(pattern, roptions, culture);
 
@@ -153,11 +146,7 @@ internal static void ValidateOptions(RegexOptions options)
         {
             if (((((uint)options) >> MaxOptionShift) != 0) ||
                 ((options & RegexOptions.ECMAScript) != 0 &&
-                 (options & ~(RegexOptions.ECMAScript | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Compiled | RegexOptions.NonBacktracking |
-#if DEBUG
-                             RegexOptions.Debug |
-#endif
-                             RegexOptions.CultureInvariant)) != 0))
+                 (options & ~(RegexOptions.ECMAScript | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Compiled | RegexOptions.NonBacktracking | RegexOptions.CultureInvariant)) != 0))
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.options);
             }
@@ -394,12 +383,7 @@ protected void InitializeReferences()
             RegexRunner runner = Interlocked.Exchange(ref _runner, null) ?? CreateRunner();
             try
             {
-                // Do the scan starting at the requested position
-                Match? match = runner.Scan(this, input, beginning, beginning + length, startat, prevlen, quick, internalMatchTimeout);
-#if DEBUG
-                if (IsDebug) match?.Dump();
-#endif
-                return match;
+                return runner.Scan(this, input, beginning, beginning + length, startat, prevlen, quick, internalMatchTimeout);
             }
             finally
             {
@@ -410,6 +394,7 @@ protected void InitializeReferences()
         internal void Run<TState>(string input, int startat, ref TState state, MatchCallback<TState> callback, bool reuseMatchObject)
         {
             Debug.Assert((uint)startat <= (uint)input.Length);
+
             RegexRunner runner = Interlocked.Exchange(ref _runner, null) ?? CreateRunner();
             try
             {
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCharClass.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCharClass.cs
index d52e2889786f7a..d4a8fb4f3b2324 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCharClass.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCharClass.cs
@@ -1815,7 +1815,7 @@ private static string[] PopulateCategoryIdToName()
         /// Produces a human-readable description for a set string.
         /// </summary>
         [ExcludeFromCodeCoverage]
-        public static string SetDescription(string set)
+        public static string DescribeSet(string set)
         {
             int setLength = set[SetLengthIndex];
             int categoryLength = set[CategoryLengthIndex];
@@ -1841,7 +1841,7 @@ public static string SetDescription(string set)
                     (char)(set[index + 1] - 1) :
                     LastChar;
 
-                desc.Append(CharDescription(ch1));
+                desc.Append(DescribeChar(ch1));
 
                 if (ch2 != ch1)
                 {
@@ -1850,7 +1850,7 @@ public static string SetDescription(string set)
                         desc.Append('-');
                     }
 
-                    desc.Append(CharDescription(ch2));
+                    desc.Append(DescribeChar(ch2));
                 }
                 index += 2;
             }
@@ -1899,7 +1899,7 @@ public static string SetDescription(string set)
                 }
                 else
                 {
-                    desc.Append(CategoryDescription(ch1));
+                    desc.Append(DescribeCategory(ch1));
                 }
 
                 index++;
@@ -1907,7 +1907,7 @@ public static string SetDescription(string set)
 
             if (set.Length > endPosition)
             {
-                desc.Append('-').Append(SetDescription(set.Substring(endPosition)));
+                desc.Append('-').Append(DescribeSet(set.Substring(endPosition)));
             }
 
             return desc.Append(']').ToString();
@@ -1915,7 +1915,7 @@ public static string SetDescription(string set)
 
         /// <summary>Produces a human-readable description for a single character.</summary>
         [ExcludeFromCodeCoverage]
-        public static string CharDescription(char ch) =>
+        public static string DescribeChar(char ch) =>
             ch switch
             {
                 '\a' => "\\a",
@@ -1931,7 +1931,7 @@ public static string CharDescription(char ch) =>
             };
 
         [ExcludeFromCodeCoverage]
-        private static string CategoryDescription(char ch) =>
+        private static string DescribeCategory(char ch) =>
             (short)ch switch
             {
                 SpaceConst => @"\s",
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs
index 76caec6647ad21..f31d9301c47f19 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCode.cs
@@ -1,18 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-// This RegexCode class is internal to the regular expression package.
-
-// Implementation notes:
-//
-// Regexps are built into RegexCodes, which contain an operation array,
-// a string table, and some constants.
-//
-// Each operation is one of the codes below, followed by the integer
-// operands specified for each op.
-//
-// Strings and sets are indices into a string table.
-
 using System.Collections;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -20,92 +8,30 @@
 
 namespace System.Text.RegularExpressions
 {
+    /// <summary>Representation of a regular expression, written by <see cref="RegexWriter"/> and containing the code evaluated by <see cref="RegexInterpreter"/>.</summary>
+    /// <remarks>It currently stores some data used by engines other than the interpreter; that can be refactored out in the future.</remarks>
     internal sealed class RegexCode
     {
-        // The following primitive operations come directly from the parser
-
-                                                  // lef/back operands        description
-        public const int Onerep = 0;              // lef,back char,min,max    a {n}
-        public const int Notonerep = 1;           // lef,back char,min,max    .{n}
-        public const int Setrep = 2;              // lef,back set,min,max     [\d]{n}
-
-        public const int Oneloop = 3;             // lef,back char,min,max    a {,n}
-        public const int Notoneloop = 4;          // lef,back char,min,max    .{,n}
-        public const int Setloop = 5;             // lef,back set,min,max     [\d]{,n}
-
-        public const int Onelazy = 6;             // lef,back char,min,max    a {,n}?
-        public const int Notonelazy = 7;          // lef,back char,min,max    .{,n}?
-        public const int Setlazy = 8;             // lef,back set,min,max     [\d]{,n}?
-
-        public const int One = 9;                 // lef      char            a
-        public const int Notone = 10;             // lef      char            [^a]
-        public const int Set = 11;                // lef      set             [a-z\s]  \w \s \d
-
-        public const int Multi = 12;              // lef      string          abcd
-        public const int Ref = 13;                // lef      group           \#
-
-        public const int Bol = 14;                //                          ^
-        public const int Eol = 15;                //                          $
-        public const int Boundary = 16;           //                          \b
-        public const int NonBoundary = 17;        //                          \B
-        public const int Beginning = 18;          //                          \A
-        public const int Start = 19;              //                          \G
-        public const int EndZ = 20;               //                          \Z
-        public const int End = 21;                //                          \Z
-
-        public const int Nothing = 22;            //                          Reject!
-
-        // Primitive control structures
-
-        public const int Lazybranch = 23;         // back     jump            straight first
-        public const int Branchmark = 24;         // back     jump            branch first for loop
-        public const int Lazybranchmark = 25;     // back     jump            straight first for loop
-        public const int Nullcount = 26;          // back     val             set counter, null mark
-        public const int Setcount = 27;           // back     val             set counter, make mark
-        public const int Branchcount = 28;        // back     jump,limit      branch++ if zero<=c<limit
-        public const int Lazybranchcount = 29;    // back     jump,limit      same, but straight first
-        public const int Nullmark = 30;           // back                     save position
-        public const int Setmark = 31;            // back                     save position
-        public const int Capturemark = 32;        // back     group           define group
-        public const int Getmark = 33;            // back                     recall position
-        public const int Setjump = 34;            // back                     save backtrack state
-        public const int Backjump = 35;           //                          zap back to saved state
-        public const int Forejump = 36;           //                          zap backtracking state
-        public const int Testref = 37;            //                          backtrack if ref undefined
-        public const int Goto = 38;               //          jump            just go
-
-        public const int Stop = 40;               //                          done!
-
-        public const int ECMABoundary = 41;       //                          \b
-        public const int NonECMABoundary = 42;    //                          \B
-
-        // Manufactured primitive operations, derived from the tree that comes from the parser.
-        // These exist to reduce backtracking (both actually performing it and spitting code for it).
-
-        public const int Oneloopatomic = 43;      // lef,back char,min,max    (?> a {,n} )
-        public const int Notoneloopatomic = 44;   // lef,back set,min,max     (?> . {,n} )
-        public const int Setloopatomic = 45;      // lef,back set,min,max     (?> [\d]{,n} )
-        public const int UpdateBumpalong = 46;    // updates the bumpalong position to the current position
-
-        // Modifiers for alternate modes
-        public const int Mask = 63;   // Mask to get unmodified ordinary operator
-        public const int Rtl = 64;    // bit to indicate that we're reverse scanning.
-        public const int Back = 128;  // bit to indicate that we're backtracking.
-        public const int Back2 = 256; // bit to indicate that we're backtracking on a second branch.
-        public const int Ci = 512;    // bit to indicate that we're case-insensitive.
-
-        public readonly RegexTree Tree;                                                 // the optimized parse tree
-        public readonly int[] Codes;                                                    // the code
-        public readonly string[] Strings;                                               // the string/set table
-        public readonly uint[]?[] StringsAsciiLookup;                                   // the ASCII lookup table optimization for the sets in Strings
-        public readonly int TrackCount;                                                 // how many instructions use backtracking
-        public readonly Hashtable? Caps;                                                // mapping of user group numbers -> impl group slots
-        public readonly int CapSize;                                                    // number of impl group slots
-        public readonly bool RightToLeft;                                               // true if right to left
+        /// <summary>The optimized parse tree.</summary>
+        public readonly RegexTree Tree;
+        /// <summary>RegexOpcodes and arguments written by <see cref="RegexWriter"/>.</summary>
+        public readonly int[] Codes;
+        /// <summary>The string / set table. <see cref="Codes"/> includes offsets into this table, for string and set arguments.</summary>
+        public readonly string[] Strings;
+        /// <summary>ASCII lookup table optimization for sets in <see cref="Strings"/>.</summary>
+        public readonly uint[]?[] StringsAsciiLookup;
+        /// <summary>How many instructions in <see cref="Codes"/> use backtracking.</summary>
+        public readonly int TrackCount;
+        /// <summary>Mapping of user group numbers to impl group slots.</summary>
+        public readonly Hashtable? Caps;
+        /// <summary>Number of impl group slots.</summary>
+        public readonly int CapSize;
+        /// <summary>True if right to left.</summary>
+        public readonly bool RightToLeft;
+        /// <summary>Optimization mode and supporting data to enable quickly finding the next possible match location.</summary>
         public readonly RegexFindOptimizations FindOptimizations;
 
-        public RegexCode(RegexTree tree, CultureInfo culture, int[] codes, string[] strings, int trackcount,
-                         Hashtable? caps, int capsize)
+        public RegexCode(RegexTree tree, CultureInfo culture, int[] codes, string[] strings, int trackcount, Hashtable? caps, int capsize)
         {
             Tree = tree;
             Codes = codes;
@@ -118,32 +44,33 @@ public RegexCode(RegexTree tree, CultureInfo culture, int[] codes, string[] stri
             FindOptimizations = new RegexFindOptimizations(tree, culture);
         }
 
-        public static bool OpcodeBacktracks(int Op)
+        /// <summary>Gets whether the specified opcode may incur backtracking.</summary>
+        public static bool OpcodeBacktracks(RegexOpcode opcode)
         {
-            Op &= Mask;
+            opcode &= RegexOpcode.OperatorMask;
 
-            switch (Op)
+            switch (opcode)
             {
-                case Oneloop:
-                case Notoneloop:
-                case Setloop:
-                case Onelazy:
-                case Notonelazy:
-                case Setlazy:
-                case Lazybranch:
-                case Branchmark:
-                case Lazybranchmark:
-                case Nullcount:
-                case Setcount:
-                case Branchcount:
-                case Lazybranchcount:
-                case Setmark:
-                case Capturemark:
-                case Getmark:
-                case Setjump:
-                case Backjump:
-                case Forejump:
-                case Goto:
+                case RegexOpcode.Oneloop:
+                case RegexOpcode.Onelazy:
+                case RegexOpcode.Notoneloop:
+                case RegexOpcode.Notonelazy:
+                case RegexOpcode.Setloop:
+                case RegexOpcode.Setlazy:
+                case RegexOpcode.Lazybranch:
+                case RegexOpcode.Branchmark:
+                case RegexOpcode.Lazybranchmark:
+                case RegexOpcode.Nullcount:
+                case RegexOpcode.Setcount:
+                case RegexOpcode.Branchcount:
+                case RegexOpcode.Lazybranchcount:
+                case RegexOpcode.Setmark:
+                case RegexOpcode.Capturemark:
+                case RegexOpcode.Getmark:
+                case RegexOpcode.Setjump:
+                case RegexOpcode.Backjump:
+                case RegexOpcode.Forejump:
+                case RegexOpcode.Goto:
                     return true;
 
                 default:
@@ -151,265 +78,188 @@ public static bool OpcodeBacktracks(int Op)
             }
         }
 
-        public static int OpcodeSize(int opcode)
+        /// <summary>Gets the number of integers required to store an operation represented by the specified opcode (including the opcode).</summary>
+        /// <returns>Values range from 1 (just the opcode) to 3 (the opcode plus up to two operands).</returns>
+        public static int OpcodeSize(RegexOpcode opcode)
         {
-            opcode &= Mask;
-
+            opcode &= RegexOpcode.OperatorMask;
             switch (opcode)
             {
-                case Nothing:
-                case Bol:
-                case Eol:
-                case Boundary:
-                case NonBoundary:
-                case ECMABoundary:
-                case NonECMABoundary:
-                case Beginning:
-                case Start:
-                case EndZ:
-                case End:
-                case Nullmark:
-                case Setmark:
-                case Getmark:
-                case Setjump:
-                case Backjump:
-                case Forejump:
-                case Stop:
-                case UpdateBumpalong:
+                case RegexOpcode.Nothing:
+                case RegexOpcode.Bol:
+                case RegexOpcode.Eol:
+                case RegexOpcode.Boundary:
+                case RegexOpcode.NonBoundary:
+                case RegexOpcode.ECMABoundary:
+                case RegexOpcode.NonECMABoundary:
+                case RegexOpcode.Beginning:
+                case RegexOpcode.Start:
+                case RegexOpcode.EndZ:
+                case RegexOpcode.End:
+                case RegexOpcode.Nullmark:
+                case RegexOpcode.Setmark:
+                case RegexOpcode.Getmark:
+                case RegexOpcode.Setjump:
+                case RegexOpcode.Backjump:
+                case RegexOpcode.Forejump:
+                case RegexOpcode.Stop:
+                case RegexOpcode.UpdateBumpalong:
+                    // The opcode has no operands.
                     return 1;
 
-                case One:
-                case Notone:
-                case Multi:
-                case Ref:
-                case Testref:
-                case Goto:
-                case Nullcount:
-                case Setcount:
-                case Lazybranch:
-                case Branchmark:
-                case Lazybranchmark:
-                case Set:
+                case RegexOpcode.One:
+                case RegexOpcode.Notone:
+                case RegexOpcode.Multi:
+                case RegexOpcode.Backreference:
+                case RegexOpcode.TestBackreference:
+                case RegexOpcode.Goto:
+                case RegexOpcode.Nullcount:
+                case RegexOpcode.Setcount:
+                case RegexOpcode.Lazybranch:
+                case RegexOpcode.Branchmark:
+                case RegexOpcode.Lazybranchmark:
+                case RegexOpcode.Set:
+                    // The opcode has one operand.
                     return 2;
 
-                case Capturemark:
-                case Branchcount:
-                case Lazybranchcount:
-                case Onerep:
-                case Notonerep:
-                case Oneloop:
-                case Oneloopatomic:
-                case Notoneloop:
-                case Notoneloopatomic:
-                case Onelazy:
-                case Notonelazy:
-                case Setlazy:
-                case Setrep:
-                case Setloop:
-                case Setloopatomic:
+                case RegexOpcode.Capturemark:
+                case RegexOpcode.Branchcount:
+                case RegexOpcode.Lazybranchcount:
+                case RegexOpcode.Onerep:
+                case RegexOpcode.Notonerep:
+                case RegexOpcode.Oneloop:
+                case RegexOpcode.Oneloopatomic:
+                case RegexOpcode.Notoneloop:
+                case RegexOpcode.Notoneloopatomic:
+                case RegexOpcode.Onelazy:
+                case RegexOpcode.Notonelazy:
+                case RegexOpcode.Setlazy:
+                case RegexOpcode.Setrep:
+                case RegexOpcode.Setloop:
+                case RegexOpcode.Setloopatomic:
+                    // The opcode has two operands.
                     return 3;
 
                 default:
-                    Debug.Fail($"Unexpected opcode: {opcode}");
-                    return 0;
+                    Debug.Fail($"Unknown opcode: {opcode}");
+                    goto case RegexOpcode.Stop;
             }
         }
 
+#if DEBUG
         [ExcludeFromCodeCoverage]
-        private static string OperatorDescription(int Opcode)
+        public override string ToString()
         {
-            string codeStr = (Opcode & Mask) switch
+            var sb = new StringBuilder();
+
+            sb.AppendLine($"Direction: {(RightToLeft ? "right-to-left" : "left-to-right")}");
+            sb.AppendLine($"Anchor:    {FindOptimizations.LeadingAnchor}");
+            sb.AppendLine();
+            for (int i = 0; i < Codes.Length; i += OpcodeSize((RegexOpcode)Codes[i]))
             {
-                Onerep => nameof(Onerep),
-                Notonerep => nameof(Notonerep),
-                Setrep => nameof(Setrep),
-                Oneloop => nameof(Oneloop),
-                Notoneloop => nameof(Notoneloop),
-                Setloop => nameof(Setloop),
-                Onelazy => nameof(Onelazy),
-                Notonelazy => nameof(Notonelazy),
-                Setlazy => nameof(Setlazy),
-                One => nameof(One),
-                Notone => nameof(Notone),
-                Set => nameof(Set),
-                Multi => nameof(Multi),
-                Ref => nameof(Ref),
-                Bol => nameof(Bol),
-                Eol => nameof(Eol),
-                Boundary => nameof(Boundary),
-                NonBoundary => nameof(NonBoundary),
-                Beginning => nameof(Beginning),
-                Start => nameof(Start),
-                EndZ => nameof(EndZ),
-                End => nameof(End),
-                Nothing => nameof(Nothing),
-                Lazybranch => nameof(Lazybranch),
-                Branchmark => nameof(Branchmark),
-                Lazybranchmark => nameof(Lazybranchmark),
-                Nullcount => nameof(Nullcount),
-                Setcount => nameof(Setcount),
-                Branchcount => nameof(Branchcount),
-                Lazybranchcount => nameof(Lazybranchcount),
-                Nullmark => nameof(Nullmark),
-                Setmark => nameof(Setmark),
-                Capturemark => nameof(Capturemark),
-                Getmark => nameof(Getmark),
-                Setjump => nameof(Setjump),
-                Backjump => nameof(Backjump),
-                Forejump => nameof(Forejump),
-                Testref => nameof(Testref),
-                Goto => nameof(Goto),
-                Stop => nameof(Stop),
-                ECMABoundary => nameof(ECMABoundary),
-                NonECMABoundary => nameof(NonECMABoundary),
-                Oneloopatomic => nameof(Oneloopatomic),
-                Notoneloopatomic => nameof(Notoneloopatomic),
-                Setloopatomic => nameof(Setloopatomic),
-                UpdateBumpalong => nameof(UpdateBumpalong),
-                _ => "(unknown)"
-            };
+                sb.AppendLine(DescribeInstruction(i));
+            }
 
-            return
-                codeStr +
-                ((Opcode & Ci) != 0 ? "-Ci" : "") +
-                ((Opcode & Rtl) != 0 ? "-Rtl" : "") +
-                ((Opcode & Back) != 0 ? "-Back" : "") +
-                ((Opcode & Back2) != 0 ? "-Back2" : "");
+            return sb.ToString();
         }
 
         [ExcludeFromCodeCoverage]
-        internal string OpcodeDescription(int offset) => OpcodeDescription(offset, Codes, Strings);
-
-        [ExcludeFromCodeCoverage]
-        internal static string OpcodeDescription(int offset, int[] codes, string[] strings)
+        internal string DescribeInstruction(int opcodeOffset)
         {
-            var sb = new StringBuilder();
-            int opcode = codes[offset];
+            RegexOpcode opcode = (RegexOpcode)Codes[opcodeOffset];
 
-            sb.Append($"{offset:D6} ");
-            sb.Append(OpcodeBacktracks(opcode & Mask) ? '*' : ' ');
-            sb.Append(OperatorDescription(opcode));
+            var sb = new StringBuilder();
+            sb.Append($"{opcodeOffset:D6} ");
+            sb.Append(OpcodeBacktracks(opcode & RegexOpcode.OperatorMask) ? '~' : ' ');
+            sb.Append(opcode & RegexOpcode.OperatorMask);
+            if ((opcode & RegexOpcode.CaseInsensitive) != 0) sb.Append("-Ci");
+            if ((opcode & RegexOpcode.RightToLeft) != 0) sb.Append("-Rtl");
+            if ((opcode & RegexOpcode.Backtracking) != 0) sb.Append("-Back");
+            if ((opcode & RegexOpcode.BacktrackingSecond) != 0) sb.Append("-Back2");
 
-            opcode &= Mask;
+            opcode &= RegexOpcode.OperatorMask;
 
             switch (opcode)
             {
-                case One:
-                case Notone:
-                case Onerep:
-                case Notonerep:
-                case Oneloop:
-                case Oneloopatomic:
-                case Notoneloop:
-                case Notoneloopatomic:
-                case Onelazy:
-                case Notonelazy:
-                    sb.Append(Indent()).Append('\'').Append(RegexCharClass.CharDescription((char)codes[offset + 1])).Append('\'');
+                case RegexOpcode.One:
+                case RegexOpcode.Onerep:
+                case RegexOpcode.Oneloop:
+                case RegexOpcode.Oneloopatomic:
+                case RegexOpcode.Onelazy:
+                case RegexOpcode.Notone:
+                case RegexOpcode.Notonerep:
+                case RegexOpcode.Notoneloop:
+                case RegexOpcode.Notoneloopatomic:
+                case RegexOpcode.Notonelazy:
+                    sb.Append(Indent()).Append('\'').Append(RegexCharClass.DescribeChar((char)Codes[opcodeOffset + 1])).Append('\'');
                     break;
 
-                case Set:
-                case Setrep:
-                case Setloop:
-                case Setloopatomic:
-                case Setlazy:
-                    sb.Append(Indent()).Append(RegexCharClass.SetDescription(strings[codes[offset + 1]]));
+                case RegexOpcode.Set:
+                case RegexOpcode.Setrep:
+                case RegexOpcode.Setloop:
+                case RegexOpcode.Setloopatomic:
+                case RegexOpcode.Setlazy:
+                    sb.Append(Indent()).Append(RegexCharClass.DescribeSet(Strings[Codes[opcodeOffset + 1]]));
                     break;
 
-                case Multi:
-                    sb.Append(Indent()).Append('"').Append(strings[codes[offset + 1]]).Append('"');
+                case RegexOpcode.Multi:
+                    sb.Append(Indent()).Append('"').Append(Strings[Codes[opcodeOffset + 1]]).Append('"');
                     break;
 
-                case Ref:
-                case Testref:
-                    sb.Append(Indent()).Append("index = ").Append(codes[offset + 1]);
+                case RegexOpcode.Backreference:
+                case RegexOpcode.TestBackreference:
+                    sb.Append(Indent()).Append("index = ").Append(Codes[opcodeOffset + 1]);
                     break;
 
-                case Capturemark:
-                    sb.Append(Indent()).Append("index = ").Append(codes[offset + 1]);
-                    if (codes[offset + 2] != -1)
+                case RegexOpcode.Capturemark:
+                    sb.Append(Indent()).Append("index = ").Append(Codes[opcodeOffset + 1]);
+                    if (Codes[opcodeOffset + 2] != -1)
                     {
-                        sb.Append(", unindex = ").Append(codes[offset + 2]);
+                        sb.Append(", unindex = ").Append(Codes[opcodeOffset + 2]);
                     }
                     break;
 
-                case Nullcount:
-                case Setcount:
-                    sb.Append(Indent()).Append("value = ").Append(codes[offset + 1]);
+                case RegexOpcode.Nullcount:
+                case RegexOpcode.Setcount:
+                    sb.Append(Indent()).Append("value = ").Append(Codes[opcodeOffset + 1]);
                     break;
 
-                case Goto:
-                case Lazybranch:
-                case Branchmark:
-                case Lazybranchmark:
-                case Branchcount:
-                case Lazybranchcount:
-                    sb.Append(Indent()).Append("addr = ").Append(codes[offset + 1]);
+                case RegexOpcode.Goto:
+                case RegexOpcode.Lazybranch:
+                case RegexOpcode.Branchmark:
+                case RegexOpcode.Lazybranchmark:
+                case RegexOpcode.Branchcount:
+                case RegexOpcode.Lazybranchcount:
+                    sb.Append(Indent()).Append("addr = ").Append(Codes[opcodeOffset + 1]);
                     break;
             }
 
             switch (opcode)
             {
-                case Onerep:
-                case Notonerep:
-                case Oneloop:
-                case Oneloopatomic:
-                case Notoneloop:
-                case Notoneloopatomic:
-                case Onelazy:
-                case Notonelazy:
-                case Setrep:
-                case Setloop:
-                case Setloopatomic:
-                case Setlazy:
-                    sb.Append(", rep = ");
-                    if (codes[offset + 2] == int.MaxValue)
-                    {
-                        sb.Append("inf");
-                    }
-                    else
-                    {
-                        sb.Append(codes[offset + 2]);
-                    }
+                case RegexOpcode.Onerep:
+                case RegexOpcode.Oneloop:
+                case RegexOpcode.Oneloopatomic:
+                case RegexOpcode.Onelazy:
+                case RegexOpcode.Notonerep:
+                case RegexOpcode.Notoneloop:
+                case RegexOpcode.Notoneloopatomic:
+                case RegexOpcode.Notonelazy:
+                case RegexOpcode.Setrep:
+                case RegexOpcode.Setloop:
+                case RegexOpcode.Setloopatomic:
+                case RegexOpcode.Setlazy:
+                    sb.Append(", rep = ").Append(Codes[opcodeOffset + 2] == int.MaxValue ? "inf" : Codes[opcodeOffset + 2]);
                     break;
 
-                case Branchcount:
-                case Lazybranchcount:
-                    sb.Append(", limit = ");
-                    if (codes[offset + 2] == int.MaxValue)
-                    {
-                        sb.Append("inf");
-                    }
-                    else
-                    {
-                        sb.Append(codes[offset + 2]);
-                    }
+                case RegexOpcode.Branchcount:
+                case RegexOpcode.Lazybranchcount:
+                    sb.Append(", limit = ").Append(Codes[opcodeOffset + 2] == int.MaxValue ? "inf" : Codes[opcodeOffset + 2]);
                     break;
             }
 
-            string Indent() => new string(' ', Math.Max(1, 25 - sb.Length));
-
             return sb.ToString();
-        }
-
-#if DEBUG
-        [ExcludeFromCodeCoverage]
-        public void Dump() => Debug.WriteLine(ToString());
-
-        [ExcludeFromCodeCoverage]
-        public override string ToString()
-        {
-            var sb = new StringBuilder();
 
-            sb.AppendLine($"Direction:  {(RightToLeft ? "right-to-left" : "left-to-right")}");
-            sb.AppendLine($"Anchor:     {FindOptimizations.LeadingAnchor}");
-            sb.AppendLine();
-            for (int i = 0; i < Codes.Length; i += OpcodeSize(Codes[i]))
-            {
-                sb.AppendLine(OpcodeDescription(i));
-            }
-            sb.AppendLine();
-
-            return sb.ToString();
+            string Indent() => new string(' ', Math.Max(1, 25 - sb.Length));
         }
 #endif
     }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
index 4bba264296327e..96ca0512634625 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompiler.cs
@@ -3934,9 +3934,9 @@ private void InitializeCultureForGoIfNecessary()
                 if (!needsCulture)
                 {
                     int[] codes = _code!.Codes;
-                    for (int codepos = 0; codepos < codes.Length; codepos += RegexCode.OpcodeSize(codes[codepos]))
+                    for (int codepos = 0; codepos < codes.Length; codepos += RegexCode.OpcodeSize((RegexOpcode)codes[codepos]))
                     {
-                        if ((codes[codepos] & RegexCode.Ci) == RegexCode.Ci)
+                        if (((RegexOpcode)codes[codepos] & RegexOpcode.CaseInsensitive) == RegexOpcode.CaseInsensitive)
                         {
                             needsCulture = true;
                             break;
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexInterpreter.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexInterpreter.cs
index 3f3f2808a01ef4..9f615754a808fd 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexInterpreter.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexInterpreter.cs
@@ -16,7 +16,7 @@ internal sealed class RegexInterpreter : RegexRunner
         private readonly RegexCode _code;
         private readonly TextInfo _textInfo;
 
-        private int _operator;
+        private RegexOpcode _operator;
         private int _codepos;
         private bool _rightToLeft;
         private bool _caseInsensitive;
@@ -35,7 +35,7 @@ public RegexInterpreter(RegexCode code, CultureInfo culture)
         private void Advance(int i)
         {
             _codepos += i + 1;
-            SetOperator(_code.Codes[_codepos]);
+            SetOperator((RegexOpcode)_code.Codes[_codepos]);
         }
 
         private void Goto(int newpos)
@@ -47,7 +47,7 @@ private void Goto(int newpos)
             }
 
             _codepos = newpos;
-            SetOperator(_code.Codes[newpos]);
+            SetOperator((RegexOpcode)_code.Codes[newpos]);
         }
 
         private void Trackto(int newpos) => runtrackpos = runtrack!.Length - newpos;
@@ -122,21 +122,16 @@ private void Backtrack()
             runtrackpos++;
 
 #if DEBUG
-            if (runmatch!.IsDebug)
-            {
-                Debug.WriteLine(newpos < 0 ?
-                    $"       Backtracking (back2) to code position {-newpos}" :
-                    $"       Backtracking to code position {newpos}");
-            }
+            Debug.WriteLineIf(Regex.EnableDebugTracing, $"       Backtracking{(newpos < 0 ? " (back2)" : "")} to code position {Math.Abs(newpos)}");
 #endif
 
-            int back = RegexCode.Back;
+            int back = (int)RegexOpcode.Backtracking;
             if (newpos < 0)
             {
                 newpos = -newpos;
-                back = RegexCode.Back2;
+                back = (int)RegexOpcode.BacktrackingSecond;
             }
-            SetOperator(_code.Codes[newpos] | back);
+            SetOperator((RegexOpcode)(_code.Codes[newpos] | back));
 
             // When branching backward, ensure storage.
             if (newpos < _codepos)
@@ -148,11 +143,11 @@ private void Backtrack()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void SetOperator(int op)
+        private void SetOperator(RegexOpcode op)
         {
-            _operator = op & ~(RegexCode.Rtl | RegexCode.Ci);
-            _caseInsensitive = (op & RegexCode.Ci) != 0;
-            _rightToLeft = (op & RegexCode.Rtl) != 0;
+            _operator = op & ~(RegexOpcode.RightToLeft | RegexOpcode.CaseInsensitive);
+            _caseInsensitive = (op & RegexOpcode.CaseInsensitive) != 0;
+            _rightToLeft = (op & RegexOpcode.RightToLeft) != 0;
         }
 
         private void TrackPop() => runtrackpos++;
@@ -334,7 +329,7 @@ protected override bool FindFirstChar() =>
 
         protected override void Go()
         {
-            SetOperator(_code.Codes[0]);
+            SetOperator((RegexOpcode)_code.Codes[0]);
             _codepos = 0;
             int advance = -1;
             ReadOnlySpan<char> inputSpan = runtext;
@@ -349,26 +344,26 @@ protected override void Go()
                     advance = -1;
                 }
 #if DEBUG
-                if (runmatch!.IsDebug)
+                if (Regex.EnableDebugTracing)
                 {
-                    DumpState();
+                    DebugTraceCurrentState();
                 }
 #endif
                 CheckTimeout();
 
                 switch (_operator)
                 {
-                    case RegexCode.Stop:
+                    case RegexOpcode.Stop:
                         return;
 
-                    case RegexCode.Nothing:
+                    case RegexOpcode.Nothing:
                         break;
 
-                    case RegexCode.Goto:
+                    case RegexOpcode.Goto:
                         Goto(Operand(0));
                         continue;
 
-                    case RegexCode.Testref:
+                    case RegexOpcode.TestBackreference:
                         if (!IsMatched(Operand(0)))
                         {
                             break;
@@ -376,47 +371,47 @@ protected override void Go()
                         advance = 1;
                         continue;
 
-                    case RegexCode.Lazybranch:
+                    case RegexOpcode.Lazybranch:
                         TrackPush(runtextpos);
                         advance = 1;
                         continue;
 
-                    case RegexCode.Lazybranch | RegexCode.Back:
+                    case RegexOpcode.Lazybranch | RegexOpcode.Backtracking:
                         TrackPop();
                         runtextpos = TrackPeek();
                         Goto(Operand(0));
                         continue;
 
-                    case RegexCode.Setmark:
+                    case RegexOpcode.Setmark:
                         StackPush(runtextpos);
                         TrackPush();
                         advance = 0;
                         continue;
 
-                    case RegexCode.Nullmark:
+                    case RegexOpcode.Nullmark:
                         StackPush(-1);
                         TrackPush();
                         advance = 0;
                         continue;
 
-                    case RegexCode.Setmark | RegexCode.Back:
-                    case RegexCode.Nullmark | RegexCode.Back:
+                    case RegexOpcode.Setmark | RegexOpcode.Backtracking:
+                    case RegexOpcode.Nullmark | RegexOpcode.Backtracking:
                         StackPop();
                         break;
 
-                    case RegexCode.Getmark:
+                    case RegexOpcode.Getmark:
                         StackPop();
                         TrackPush(StackPeek());
                         runtextpos = StackPeek();
                         advance = 0;
                         continue;
 
-                    case RegexCode.Getmark | RegexCode.Back:
+                    case RegexOpcode.Getmark | RegexOpcode.Backtracking:
                         TrackPop();
                         StackPush(TrackPeek());
                         break;
 
-                    case RegexCode.Capturemark:
+                    case RegexOpcode.Capturemark:
                         if (Operand(1) != -1 && !IsMatched(Operand(1)))
                         {
                             break;
@@ -434,7 +429,7 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Capturemark | RegexCode.Back:
+                    case RegexOpcode.Capturemark | RegexOpcode.Backtracking:
                         TrackPop();
                         StackPush(TrackPeek());
                         Uncapture();
@@ -444,7 +439,7 @@ protected override void Go()
                         }
                         break;
 
-                    case RegexCode.Branchmark:
+                    case RegexOpcode.Branchmark:
                         StackPop();
                         if (runtextpos != StackPeek())
                         {
@@ -461,7 +456,7 @@ protected override void Go()
                         }
                         continue;
 
-                    case RegexCode.Branchmark | RegexCode.Back:
+                    case RegexOpcode.Branchmark | RegexOpcode.Backtracking:
                         TrackPop(2);
                         StackPop();
                         runtextpos = TrackPeek(1); // Recall position
@@ -469,12 +464,12 @@ protected override void Go()
                         advance = 1;               // Straight
                         continue;
 
-                    case RegexCode.Branchmark | RegexCode.Back2:
+                    case RegexOpcode.Branchmark | RegexOpcode.BacktrackingSecond:
                         TrackPop();
                         StackPush(TrackPeek()); // Recall old mark
                         break;                  // Backtrack
 
-                    case RegexCode.Lazybranchmark:
+                    case RegexOpcode.Lazybranchmark:
                         // We hit this the first time through a lazy loop and after each
                         // successful match of the inner expression.  It simply continues
                         // on and doesn't loop.
@@ -506,13 +501,13 @@ protected override void Go()
                         advance = 1;
                         continue;
 
-                    case RegexCode.Lazybranchmark | RegexCode.Back:
+                    case RegexOpcode.Lazybranchmark | RegexOpcode.Backtracking:
                         {
-                            // After the first time, Lazybranchmark | RegexCode.Back occurs
+                            // After the first time, Lazybranchmark | RegexOpcode.Back occurs
                             // with each iteration of the loop, and therefore with every attempted
                             // match of the inner expression.  We'll try to match the inner expression,
                             // then go back to Lazybranchmark if successful.  If the inner expression
-                            // fails, we go to Lazybranchmark | RegexCode.Back2
+                            // fails, we go to Lazybranchmark | RegexOpcode.Back2
                             TrackPop(2);
                             int pos = TrackPeek(1);
                             TrackPush2(TrackPeek()); // Save old mark
@@ -522,7 +517,7 @@ protected override void Go()
                         }
                         continue;
 
-                    case RegexCode.Lazybranchmark | RegexCode.Back2:
+                    case RegexOpcode.Lazybranchmark | RegexOpcode.BacktrackingSecond:
                         // The lazy loop has failed.  We'll do a true backtrack and
                         // start over before the lazy loop.
                         StackPop();
@@ -530,25 +525,25 @@ protected override void Go()
                         StackPush(TrackPeek()); // Recall old mark
                         break;
 
-                    case RegexCode.Setcount:
+                    case RegexOpcode.Setcount:
                         StackPush(runtextpos, Operand(0));
                         TrackPush();
                         advance = 1;
                         continue;
 
-                    case RegexCode.Nullcount:
+                    case RegexOpcode.Nullcount:
                         StackPush(-1, Operand(0));
                         TrackPush();
                         advance = 1;
                         continue;
 
-                    case RegexCode.Setcount | RegexCode.Back:
-                    case RegexCode.Nullcount | RegexCode.Back:
-                    case RegexCode.Setjump | RegexCode.Back:
+                    case RegexOpcode.Setcount | RegexOpcode.Backtracking:
+                    case RegexOpcode.Nullcount | RegexOpcode.Backtracking:
+                    case RegexOpcode.Setjump | RegexOpcode.Backtracking:
                         StackPop(2);
                         break;
 
-                    case RegexCode.Branchcount:
+                    case RegexOpcode.Branchcount:
                         // StackPush:
                         //  0: Mark
                         //  1: Count
@@ -573,7 +568,7 @@ protected override void Go()
                         }
                         continue;
 
-                    case RegexCode.Branchcount | RegexCode.Back:
+                    case RegexOpcode.Branchcount | RegexOpcode.Backtracking:
                         // TrackPush:
                         //  0: Previous mark
                         // StackPush:
@@ -592,7 +587,7 @@ protected override void Go()
                         StackPush(TrackPeek(), StackPeek(1) - 1);      // Recall old mark, old count
                         break;
 
-                    case RegexCode.Branchcount | RegexCode.Back2:
+                    case RegexOpcode.Branchcount | RegexOpcode.BacktrackingSecond:
                         // TrackPush:
                         //  0: Previous mark
                         //  1: Previous count
@@ -600,7 +595,7 @@ protected override void Go()
                         StackPush(TrackPeek(), TrackPeek(1)); // Recall old mark, old count
                         break;                                // Backtrack
 
-                    case RegexCode.Lazybranchcount:
+                    case RegexOpcode.Lazybranchcount:
                         // StackPush:
                         //  0: Mark
                         //  1: Count
@@ -624,7 +619,7 @@ protected override void Go()
                         }
                         continue;
 
-                    case RegexCode.Lazybranchcount | RegexCode.Back:
+                    case RegexOpcode.Lazybranchcount | RegexOpcode.Backtracking:
                         // TrackPush:
                         //  0: Mark
                         //  1: Count
@@ -650,7 +645,7 @@ protected override void Go()
                             }
                         }
 
-                    case RegexCode.Lazybranchcount | RegexCode.Back2:
+                    case RegexOpcode.Lazybranchcount | RegexOpcode.BacktrackingSecond:
                         // TrackPush:
                         //  0: Previous mark
                         // StackPush:
@@ -661,13 +656,13 @@ protected override void Go()
                         StackPush(TrackPeek(), StackPeek(1) - 1); // Recall old mark, count
                         break;                                    // Backtrack
 
-                    case RegexCode.Setjump:
+                    case RegexOpcode.Setjump:
                         StackPush(Trackpos(), Crawlpos());
                         TrackPush();
                         advance = 0;
                         continue;
 
-                    case RegexCode.Backjump:
+                    case RegexOpcode.Backjump:
                         // StackPush:
                         //  0: Saved trackpos
                         //  1: Crawlpos
@@ -679,7 +674,7 @@ protected override void Go()
                         }
                         break;
 
-                    case RegexCode.Forejump:
+                    case RegexOpcode.Forejump:
                         // StackPush:
                         //  0: Saved trackpos
                         //  1: Crawlpos
@@ -689,7 +684,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.Forejump | RegexCode.Back:
+                    case RegexOpcode.Forejump | RegexOpcode.Backtracking:
                         // TrackPush:
                         //  0: Crawlpos
                         TrackPop();
@@ -699,7 +694,7 @@ protected override void Go()
                         }
                         break;
 
-                    case RegexCode.Bol:
+                    case RegexOpcode.Bol:
                         if (Leftchars() > 0 && inputSpan[runtextpos - 1] != '\n')
                         {
                             break;
@@ -707,7 +702,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.Eol:
+                    case RegexOpcode.Eol:
                         if (Rightchars() > 0 && inputSpan[runtextpos] != '\n')
                         {
                             break;
@@ -715,7 +710,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.Boundary:
+                    case RegexOpcode.Boundary:
                         if (!IsBoundary(runtextpos, runtextbeg, runtextend))
                         {
                             break;
@@ -723,7 +718,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.NonBoundary:
+                    case RegexOpcode.NonBoundary:
                         if (IsBoundary(runtextpos, runtextbeg, runtextend))
                         {
                             break;
@@ -731,7 +726,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.ECMABoundary:
+                    case RegexOpcode.ECMABoundary:
                         if (!IsECMABoundary(runtextpos, runtextbeg, runtextend))
                         {
                             break;
@@ -739,7 +734,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.NonECMABoundary:
+                    case RegexOpcode.NonECMABoundary:
                         if (IsECMABoundary(runtextpos, runtextbeg, runtextend))
                         {
                             break;
@@ -747,7 +742,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.Beginning:
+                    case RegexOpcode.Beginning:
                         if (Leftchars() > 0)
                         {
                             break;
@@ -755,7 +750,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.Start:
+                    case RegexOpcode.Start:
                         if (runtextpos != runtextstart)
                         {
                             break;
@@ -763,7 +758,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.EndZ:
+                    case RegexOpcode.EndZ:
                         if (Rightchars() > 1 || Rightchars() == 1 && inputSpan[runtextpos] != '\n')
                         {
                             break;
@@ -771,7 +766,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.End:
+                    case RegexOpcode.End:
                         if (Rightchars() > 0)
                         {
                             break;
@@ -779,7 +774,7 @@ protected override void Go()
                         advance = 0;
                         continue;
 
-                    case RegexCode.One:
+                    case RegexOpcode.One:
                         if (Forwardchars() < 1 || Forwardcharnext(inputSpan) != (char)Operand(0))
                         {
                             break;
@@ -787,7 +782,7 @@ protected override void Go()
                         advance = 1;
                         continue;
 
-                    case RegexCode.Notone:
+                    case RegexOpcode.Notone:
                         if (Forwardchars() < 1 || Forwardcharnext(inputSpan) == (char)Operand(0))
                         {
                             break;
@@ -795,7 +790,7 @@ protected override void Go()
                         advance = 1;
                         continue;
 
-                    case RegexCode.Set:
+                    case RegexOpcode.Set:
                         if (Forwardchars() < 1)
                         {
                             break;
@@ -811,7 +806,7 @@ protected override void Go()
                         advance = 1;
                         continue;
 
-                    case RegexCode.Multi:
+                    case RegexOpcode.Multi:
                         if (!MatchString(_code.Strings[Operand(0)], inputSpan))
                         {
                             break;
@@ -819,7 +814,7 @@ protected override void Go()
                         advance = 1;
                         continue;
 
-                    case RegexCode.Ref:
+                    case RegexOpcode.Backreference:
                         {
                             int capnum = Operand(0);
                             if (IsMatched(capnum))
@@ -840,7 +835,7 @@ protected override void Go()
                         advance = 1;
                         continue;
 
-                    case RegexCode.Onerep:
+                    case RegexOpcode.Onerep:
                         {
                             int c = Operand(1);
                             if (Forwardchars() < c)
@@ -860,7 +855,7 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Notonerep:
+                    case RegexOpcode.Notonerep:
                         {
                             int c = Operand(1);
                             if (Forwardchars() < c)
@@ -880,7 +875,7 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Setrep:
+                    case RegexOpcode.Setrep:
                         {
                             int c = Operand(1);
                             if (Forwardchars() < c)
@@ -909,8 +904,8 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Oneloop:
-                    case RegexCode.Oneloopatomic:
+                    case RegexOpcode.Oneloop:
+                    case RegexOpcode.Oneloopatomic:
                         {
                             int len = Math.Min(Operand(1), Forwardchars());
                             char ch = (char)Operand(0);
@@ -925,7 +920,7 @@ protected override void Go()
                                 }
                             }
 
-                            if (len > i && _operator == RegexCode.Oneloop)
+                            if (len > i && _operator == RegexOpcode.Oneloop)
                             {
                                 TrackPush(len - i - 1, runtextpos - Bump());
                             }
@@ -933,8 +928,8 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Notoneloop:
-                    case RegexCode.Notoneloopatomic:
+                    case RegexOpcode.Notoneloop:
+                    case RegexOpcode.Notoneloopatomic:
                         {
                             int len = Math.Min(Operand(1), Forwardchars());
                             char ch = (char)Operand(0);
@@ -968,7 +963,7 @@ protected override void Go()
                                 }
                             }
 
-                            if (len > i && _operator == RegexCode.Notoneloop)
+                            if (len > i && _operator == RegexOpcode.Notoneloop)
                             {
                                 TrackPush(len - i - 1, runtextpos - Bump());
                             }
@@ -976,8 +971,8 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Setloop:
-                    case RegexCode.Setloopatomic:
+                    case RegexOpcode.Setloop:
+                    case RegexOpcode.Setloopatomic:
                         {
                             int len = Math.Min(Operand(1), Forwardchars());
                             int operand0 = Operand(0);
@@ -1000,7 +995,7 @@ protected override void Go()
                                 }
                             }
 
-                            if (len > i && _operator == RegexCode.Setloop)
+                            if (len > i && _operator == RegexOpcode.Setloop)
                             {
                                 TrackPush(len - i - 1, runtextpos - Bump());
                             }
@@ -1008,9 +1003,9 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Oneloop | RegexCode.Back:
-                    case RegexCode.Notoneloop | RegexCode.Back:
-                    case RegexCode.Setloop | RegexCode.Back:
+                    case RegexOpcode.Oneloop | RegexOpcode.Backtracking:
+                    case RegexOpcode.Notoneloop | RegexOpcode.Backtracking:
+                    case RegexOpcode.Setloop | RegexOpcode.Backtracking:
                         TrackPop(2);
                         {
                             int i = TrackPeek();
@@ -1024,9 +1019,9 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Onelazy:
-                    case RegexCode.Notonelazy:
-                    case RegexCode.Setlazy:
+                    case RegexOpcode.Onelazy:
+                    case RegexOpcode.Notonelazy:
+                    case RegexOpcode.Setlazy:
                         {
                             int c = Math.Min(Operand(1), Forwardchars());
                             if (c > 0)
@@ -1037,7 +1032,7 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Onelazy | RegexCode.Back:
+                    case RegexOpcode.Onelazy | RegexOpcode.Backtracking:
                         TrackPop(2);
                         {
                             int pos = TrackPeek(1);
@@ -1057,7 +1052,7 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Notonelazy | RegexCode.Back:
+                    case RegexOpcode.Notonelazy | RegexOpcode.Backtracking:
                         TrackPop(2);
                         {
                             int pos = TrackPeek(1);
@@ -1077,7 +1072,7 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.Setlazy | RegexCode.Back:
+                    case RegexOpcode.Setlazy | RegexOpcode.Backtracking:
                         TrackPop(2);
                         {
                             int pos = TrackPeek(1);
@@ -1098,7 +1093,7 @@ protected override void Go()
                         advance = 2;
                         continue;
 
-                    case RegexCode.UpdateBumpalong:
+                    case RegexOpcode.UpdateBumpalong:
                         // UpdateBumpalong should only exist in the code stream at such a point where the root
                         // of the backtracking stack contains the runtextpos from the start of this Go call. Replace
                         // that tracking value with the current runtextpos value if it's greater.
@@ -1125,14 +1120,10 @@ protected override void Go()
 
 #if DEBUG
         [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        internal override void DumpState()
+        internal override void DebugTraceCurrentState()
         {
-            base.DumpState();
-            Debug.WriteLine(
-                "       " +
-                _code.OpcodeDescription(_codepos) +
-                ((_operator & RegexCode.Back) != 0 ? " Back" : "") +
-                ((_operator & RegexCode.Back2) != 0 ? " Back2" : ""));
+            base.DebugTraceCurrentState();
+            Debug.WriteLine($"       {_code.DescribeInstruction(_codepos)} {((_operator & RegexOpcode.Backtracking) != 0 ? " Back" : "")} {((_operator & RegexOpcode.BacktrackingSecond) != 0 ? " Back2" : "")}");
             Debug.WriteLine("");
         }
 #endif
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
index efd5ef3d45a251..fc16f586d948ef 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs
@@ -190,7 +190,7 @@ private void ValidateFinalTreeInvariants()
                 for (int i = 0; i < childCount; i++)
                 {
                     RegexNode child = node.Child(i);
-                    Debug.Assert(child.Parent == node, $"{child.Description()} missing reference to parent {node.Description()}");
+                    Debug.Assert(child.Parent == node, $"{child.Describe()} missing reference to parent {node.Describe()}");
 
                     toExamine.Push(child);
                 }
@@ -2568,7 +2568,40 @@ public bool IsInLoop()
 
 #if DEBUG
         [ExcludeFromCodeCoverage]
-        public string Description()
+        public override string ToString()
+        {
+            RegexNode? curNode = this;
+            int curChild = 0;
+            var sb = new StringBuilder().AppendLine(curNode.Describe());
+            var stack = new List<int>();
+            while (true)
+            {
+                if (curChild < curNode!.ChildCount())
+                {
+                    stack.Add(curChild + 1);
+                    curNode = curNode.Child(curChild);
+                    curChild = 0;
+
+                    sb.Append(new string(' ', stack.Count * 2)).Append(curNode.Describe()).AppendLine();
+                }
+                else
+                {
+                    if (stack.Count == 0)
+                    {
+                        break;
+                    }
+
+                    curChild = stack[stack.Count - 1];
+                    stack.RemoveAt(stack.Count - 1);
+                    curNode = curNode.Parent;
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        [ExcludeFromCodeCoverage]
+        private string Describe()
         {
             var sb = new StringBuilder(Kind.ToString());
 
@@ -2590,7 +2623,7 @@ public string Description()
                 case RegexNodeKind.Notonelazy:
                 case RegexNodeKind.One:
                 case RegexNodeKind.Notone:
-                    sb.Append(" '").Append(RegexCharClass.CharDescription(Ch)).Append('\'');
+                    sb.Append(" '").Append(RegexCharClass.DescribeChar(Ch)).Append('\'');
                     break;
                 case RegexNodeKind.Capture:
                     sb.Append(' ').Append($"index = {M}");
@@ -2610,7 +2643,7 @@ public string Description()
                 case RegexNodeKind.Setloop:
                 case RegexNodeKind.Setloopatomic:
                 case RegexNodeKind.Setlazy:
-                    sb.Append(' ').Append(RegexCharClass.SetDescription(Str!));
+                    sb.Append(' ').Append(RegexCharClass.DescribeSet(Str!));
                     break;
             }
 
@@ -2639,42 +2672,6 @@ public string Description()
 
             return sb.ToString();
         }
-
-        [ExcludeFromCodeCoverage]
-        public void Dump() => Debug.WriteLine(ToString());
-
-        [ExcludeFromCodeCoverage]
-        public override string ToString()
-        {
-            RegexNode? curNode = this;
-            int curChild = 0;
-            var sb = new StringBuilder().AppendLine(curNode.Description());
-            var stack = new List<int>();
-            while (true)
-            {
-                if (curChild < curNode!.ChildCount())
-                {
-                    stack.Add(curChild + 1);
-                    curNode = curNode.Child(curChild);
-                    curChild = 0;
-
-                    sb.Append(new string(' ', stack.Count * 2)).Append(curNode.Description()).AppendLine();
-                }
-                else
-                {
-                    if (stack.Count == 0)
-                    {
-                        break;
-                    }
-
-                    curChild = stack[stack.Count - 1];
-                    stack.RemoveAt(stack.Count - 1);
-                    curNode = curNode.Parent;
-                }
-            }
-
-            return sb.ToString();
-        }
 #endif
     }
 }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs
index dcf1097ea3ec70..9db755a4fdc672 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNodeKind.cs
@@ -14,95 +14,95 @@ internal enum RegexNodeKind
 
         /// <summary>A specific character, e.g. `a`.</summary>
         /// <remarks>The character is specified in <see cref="RegexNode.Ch"/>.</remarks>
-        One = RegexCode.One,
+        One = RegexOpcode.One,
         /// <summary>Anything other than a specific character, e.g. `.` when not in <see cref="RegexOptions.Singleline"/> mode, or `[^a]`.</summary>
         /// <remarks>The character is specified in <see cref="RegexNode.Ch"/>.</remarks>
-        Notone = RegexCode.Notone,
+        Notone = RegexOpcode.Notone,
         /// <summary>A character class / set, e.g. `[a-z1-9]` or `\w`.</summary>
         /// <remarks>The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>.</remarks>
-        Set = RegexCode.Set,
+        Set = RegexOpcode.Set,
 
         /// <summary>A sequence of at least two specific characters, e.g. `abc`.</summary>
         /// <remarks>The characters are specified in <see cref="RegexNode.Str"/>.  This is purely a representational optimization, equivalent to multiple <see cref="One"/> nodes concatenated together.</remarks>
-        Multi = RegexCode.Multi,
+        Multi = RegexOpcode.Multi,
 
         /// <summary>A loop around a specific character, e.g. `a*`.</summary>
         /// <remarks>
         /// The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.
         /// This is purely a representational optimization, equivalent to a <see cref="Loop"/> wrapped around a <see cref="One"/>.
         /// </remarks>
-        Oneloop = RegexCode.Oneloop,
+        Oneloop = RegexOpcode.Oneloop,
         /// <summary>A loop around anything other than a specific character, e.g. `.*` when not in <see cref="RegexOptions.Singleline"/> mode, or `[^a]*`.</summary>
         /// <remarks>The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks>
         /// This is purely a representational optimization, equivalent to a <see cref="Loop"/> wrapped around a <see cref="Notone"/>.
-        Notoneloop = RegexCode.Notoneloop,
+        Notoneloop = RegexOpcode.Notoneloop,
         /// <summary>A loop around a character class / set, e.g. `[a-z1-9]*` or `\w*`.</summary>
         /// <remarks>The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks>
         /// This is purely a representational optimization, equivalent to a <see cref="Loop"/> wrapped around a <see cref="Set"/>.
-        Setloop = RegexCode.Setloop,
+        Setloop = RegexOpcode.Setloop,
 
         /// <summary>A lazy loop around a specific character, e.g. `a*?`.</summary>
         /// <remarks>The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks>
         /// This is purely a representational optimization, equivalent to a <see cref="Lazyloop"/> wrapped around a <see cref="One"/>.
-        Onelazy = RegexCode.Onelazy,
+        Onelazy = RegexOpcode.Onelazy,
         /// <summary>A lazy loop around anything other than a specific character, e.g. `.*?` when not in <see cref="RegexOptions.Singleline"/> mode, or `[^a]*?`.</summary>
         /// <remarks>The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks>
         /// This is purely a representational optimization, equivalent to a <see cref="Lazyloop"/> wrapped around a <see cref="Notone"/>.
-        Notonelazy = RegexCode.Notonelazy,
+        Notonelazy = RegexOpcode.Notonelazy,
         /// <summary>A lazy loop around a character class / set, e.g. `[a-z1-9]*?` or `\w?`.</summary>
         /// <remarks>The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks>
         /// This is purely a representational optimization, equivalent to a <see cref="Lazyloop"/> wrapped around a <see cref="Set"/>.
-        Setlazy = RegexCode.Setlazy,
+        Setlazy = RegexOpcode.Setlazy,
 
         /// <summary>An atomic loop around a specific character, e.g. `(?> a*)`.</summary>
         /// <remarks>
         /// The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.
         /// This is purely a representational optimization, equivalent to a <see cref="Atomic"/> wrapped around a <see cref="Oneloop"/>.
         /// </remarks>
-        Oneloopatomic = RegexCode.Oneloopatomic,
+        Oneloopatomic = RegexOpcode.Oneloopatomic,
         /// <summary>An atomic loop around anything other than a specific character, e.g. `(?>.*)` when not in <see cref="RegexOptions.Singleline"/> mode.</summary>
         /// <remarks>
         /// The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.
         /// This is purely a representational optimization, equivalent to a <see cref="Atomic"/> wrapped around a <see cref="Notoneloop"/>.
         /// </remarks>
-        Notoneloopatomic = RegexCode.Notoneloopatomic,
+        Notoneloopatomic = RegexOpcode.Notoneloopatomic,
         /// <summary>An atomic loop around a character class / set, e.g. `(?>\d*)`.</summary>
         /// <remarks>
         /// The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.
         /// This is purely a representational optimization, equivalent to a <see cref="Atomic"/> wrapped around a <see cref="Setloop"/>.
         /// </remarks>
-        Setloopatomic = RegexCode.Setloopatomic,
+        Setloopatomic = RegexOpcode.Setloopatomic,
 
         /// <summary>A backreference, e.g. `\1`.</summary>
         /// <remarks>The capture group number referenced is stored in <see cref="RegexNode.M"/>.</remarks>
-        Backreference = RegexCode.Ref,
+        Backreference = RegexOpcode.Backreference,
 
         /// <summary>A beginning-of-line anchor, e.g. `^` in <see cref="RegexOptions.Multiline"/> mode.</summary>
-        Bol = RegexCode.Bol,
+        Bol = RegexOpcode.Bol,
         /// <summary>An end-of-line anchor, e.g. `$` in <see cref="RegexOptions.Multiline"/> mode.</summary>
-        Eol = RegexCode.Eol,
+        Eol = RegexOpcode.Eol,
         /// <summary>A word boundary anchor, e.g. `\b`.</summary>
-        Boundary = RegexCode.Boundary,
+        Boundary = RegexOpcode.Boundary,
         /// <summary>Not a word boundary anchor, e.g. `\B`.</summary>
-        NonBoundary = RegexCode.NonBoundary,
+        NonBoundary = RegexOpcode.NonBoundary,
         /// <summary>A word boundary anchor, e.g. `\b` in <see cref="RegexOptions.ECMAScript"/> mode.</summary>
-        ECMABoundary = RegexCode.ECMABoundary,
+        ECMABoundary = RegexOpcode.ECMABoundary,
         /// <summary>Not a word boundary anchor, e.g. `\B` in <see cref="RegexOptions.ECMAScript"/> mode..</summary>
-        NonECMABoundary = RegexCode.NonECMABoundary,
+        NonECMABoundary = RegexOpcode.NonECMABoundary,
         /// <summary>A beginning-of-string anchor, e.g. `\A`, or `^` when not in <see cref="RegexOptions.Multiline"/> mode.</summary>
-        Beginning = RegexCode.Beginning,
+        Beginning = RegexOpcode.Beginning,
         /// <summary>A start anchor, e.g. `\G`.</summary>
-        Start = RegexCode.Start,
+        Start = RegexOpcode.Start,
         /// <summary>A end-of-string-or-before-ending-newline anchor, e.g. `\Z`, or `$` when not in <see cref="RegexOptions.Multiline"/> mode.</summary>
-        EndZ = RegexCode.EndZ,
+        EndZ = RegexOpcode.EndZ,
         /// <summary>A end-of-string-only anchor, e.g. `\z`.</summary>
-        End = RegexCode.End,
+        End = RegexOpcode.End,
 
         /// <summary>A fabricated node injected during analyses to signal a location in the matching where the engine may set the next bumpalong position to the current position.</summary>
-        UpdateBumpalong = RegexCode.UpdateBumpalong,
+        UpdateBumpalong = RegexOpcode.UpdateBumpalong,
 
         /// <summary>Fails when matching an empty string, e.g. `(?!)`.</summary>
-        Nothing = 22,
+        Nothing = RegexOpcode.Nothing,
         /// <summary>Matches the empty string, e.g. ``.</summary>
         Empty = 23,
 
@@ -128,7 +128,7 @@ internal enum RegexNodeKind
         /// One and only one child, the expression in the loop. The minimum number of iterations is in <see cref="RegexNode.M"/>,
         /// and the maximum number of iterations is in <see cref="RegexNode.N"/>.
         /// </remarks>
-        Loop = 26,                                   // m,x      * + ? {,}
+        Loop = 26,
         /// <summary>A lazy loop around an arbitrary <see cref="RegexNode"/>, e.g. `(ab|cd)*?`.</summary>
         /// <remarks>
         /// One and only one child, the expression in the loop. The minimum number of iterations is in <see cref="RegexNode.M"/>,
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOpcode.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOpcode.cs
new file mode 100644
index 00000000000000..eaaa355aa97005
--- /dev/null
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOpcode.cs
@@ -0,0 +1,162 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Text.RegularExpressions
+{
+    /// <summary>Opcodes written by <see cref="RegexWriter"/> and used by <see cref="RegexInterpreter"/> to process a regex.</summary>
+    /// <remarks>
+    /// <see cref="RegexCode"/> stores an int[] containing all of the codes that make up the instructions for
+    /// the interpreter to process the regular expression.  The array contains a packed sequence of operations,
+    /// each of which is an <see cref="RegexOpcode"/> stored as an int, followed immediately by all of the operands
+    /// required for that operation.  For example, the subexpression `a{2,7}[^b]` would be represented as the sequence
+    ///     0 97 2 3 97 5 10 98
+    /// which is interpreted as:
+    ///     0  = opcode for Onerep (a{2, 7} is written out as a repeater for the minimum followed by a loop for the maximum minus the minimum)
+    ///     97 = 'a'
+    ///     2  = repeat count
+    ///     3  = opcode for Oneloop
+    ///     97 = 'a'
+    ///     5  = max iteration count
+    ///     10 = opcode for Notone
+    ///     98 = 'b'
+    /// </remarks>
+    internal enum RegexOpcode
+    {
+        // Primitive operations
+
+        /// <summary>Repeater of the specified character.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the repetition count.</remarks>
+        Onerep = 0,
+        /// <summary>Repeater of a single character other than the one specified.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the repetition count.</remarks>
+        Notonerep = 1,
+        /// <summary>Repeater of a single character matching the specified set</summary>
+        /// <remarks>Operand 0 is index into the strings table of the character class description. Operand 1 is the repetition count.</remarks>
+        Setrep = 2,
+
+        /// <summary>Greedy loop of the specified character.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the max iteration count.</remarks>
+        Oneloop = 3,
+        /// <summary>Greedy loop of a single character other than the one specified.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the max iteration count.</remarks>
+        Notoneloop = 4,
+        /// <summary>Greedy loop of a single character matching the specified set</summary>
+        /// <remarks>Operand 0 is index into the strings table of the character class description. Operand 1 is the repetition count.</remarks>
+        Setloop = 5,
+
+        /// <summary>Lazy loop of the specified character.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the max iteration count.</remarks>
+        Onelazy = 6,
+        /// <summary>Lazy loop of a single character other than the one specified.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the max iteration count.</remarks>
+        Notonelazy = 7,
+        /// <summary>Lazy loop of a single character matching the specified set</summary>
+        /// <remarks>Operand 0 is index into the strings table of the character class description. Operand 1 is the repetition count.</remarks>
+        Setlazy = 8,
+
+        /// <summary>Single specified character.</summary>
+        /// <remarks>Operand 0 is the character.</remarks>
+        One = 9,
+        /// <summary>Single character other than the one specified.</summary>
+        /// <remarks>Operand 0 is the character.</remarks>
+        Notone = 10,
+        /// <summary>Single character matching the specified set.</summary>
+        /// <remarks>Operand 0 is index into the strings table of the character class description.</remarks>
+        Set = 11,
+
+        /// <summary>Multiple characters in sequence.</summary>
+        /// <remarks>Operand 0 is index into the strings table for the string of characters.</remarks>
+        Multi = 12,
+
+        /// <summary>Backreference to a capture group.</summary>
+        /// <remarks>Operand 0 is the capture group number.</remarks>
+        Backreference = 13,
+
+        /// <summary>Beginning-of-line anchor (^ with RegexOptions.Multiline).</summary>
+        Bol = 14,
+        /// <summary>End-of-line anchor ($ with RegexOptions.Multiline).</summary>
+        Eol = 15,
+        /// <summary>Word boundary (\b).</summary>
+        Boundary = 16,
+        /// <summary>Word non-boundary (\B).</summary>
+        NonBoundary = 17,
+        /// <summary>Beginning-of-input anchor (\A).</summary>
+        Beginning = 18,
+        /// <summary>Start-of-input anchor (\G).</summary>
+        Start = 19,
+        /// <summary>End-of-input anchor (\Z).</summary>
+        EndZ = 20,
+        /// <summary>End-of-input anchor (\z).</summary>
+        End = 21,
+        /// <summary>Match nothing (fail).</summary>
+        Nothing = 22,
+        /// <summary>Word boundary (\b with RegexOptions.ECMAScript).</summary>
+        ECMABoundary = 41,
+        /// <summary>Word non-boundary (\B with RegexOptions.ECMAScript).</summary>
+        NonECMABoundary = 42,
+
+        /// <summary>Atomic loop of the specified character.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the max iteration count.</remarks>
+        Oneloopatomic = 43,
+        /// <summary>Atomic loop of a single character other than the one specified.</summary>
+        /// <remarks>Operand 0 is the character. Operand 1 is the max iteration count.</remarks>
+        Notoneloopatomic = 44,
+        /// <summary>Atomic loop of a single character matching the specified set</summary>
+        /// <remarks>Operand 0 is index into the strings table of the character class description. Operand 1 is the repetition count.</remarks>
+        Setloopatomic = 45,
+
+        /// <summary>Updates the bumpalong position to the current position.</summary>
+        UpdateBumpalong = 46,
+
+        // Primitive control structures
+        // TODO: Figure out what these comments mean / what these control structures actually do :)
+
+        /// <summary>back     jump            straight first.</summary>
+        Lazybranch = 23,
+        /// <summary>back     jump            branch first for loop.</summary>
+        Branchmark = 24,
+        /// <summary>back     jump            straight first for loop.</summary>
+        Lazybranchmark = 25,
+        /// <summary>back     val             set counter, null mark.</summary>
+        Nullcount = 26,
+        /// <summary>back     val             set counter, make mark</summary>
+        Setcount = 27,
+        /// <summary>back     jump,limit      branch++ if zero&lt;=c&lt;limit.</summary>
+        Branchcount = 28,
+        /// <summary>back     jump,limit      same, but straight first.</summary>
+        Lazybranchcount = 29,
+        /// <summary>back                     save position.</summary>
+        Nullmark = 30,
+        /// <summary>back                     save position.</summary>
+        Setmark = 31,
+        /// <summary>back     group           define group.</summary>
+        Capturemark = 32,
+        /// <summary>back                     recall position.</summary>
+        Getmark = 33,
+        /// <summary>back                     save backtrack state.</summary>
+        Setjump = 34,
+        /// <summary>zap back to saved state.</summary>
+        Backjump = 35,
+        /// <summary>zap backtracking state.</summary>
+        Forejump = 36,
+        /// <summary>Backtrack if ref undefined.</summary>
+        TestBackreference = 37,
+        /// <summary>jump            just go.</summary>
+        Goto = 38,
+        /// <summary>done!</summary>
+        Stop = 40,
+
+        // Modifiers for alternate modes
+
+        /// <summary>Mask to get unmodified ordinary operator.</summary>
+        OperatorMask = 63,
+        /// <summary>Indicates that we're reverse scanning.</summary>
+        RightToLeft = 64,
+        /// <summary>Indicates that we're backtracking.</summary>
+        Backtracking = 128,
+        /// <summary>Indicates that we're backtracking on a second branch.</summary>
+        BacktrackingSecond = 256,
+        /// <summary>Indicates that we're case-insensitive</summary>
+        CaseInsensitive = 512,
+    }
+}
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOptions.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOptions.cs
index 47b7eed807dc7b..351b1b91a9fe53 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOptions.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexOptions.cs
@@ -30,7 +30,7 @@ enum RegexOptions
         ExplicitCapture         = 0x0004, // "n"
 
         /// <summary>Compile the regular expression to Microsoft intermediate language (MSIL).</summary>
-        Compiled                = 0x0008, // "c"
+        Compiled                = 0x0008,
 
         /// <summary>
         /// Use single-line mode, where the period (.) matches every character (instead of every character except \n).
@@ -41,15 +41,10 @@ enum RegexOptions
         IgnorePatternWhitespace = 0x0020, // "x"
 
         /// <summary>Change the search direction. Search moves from right to left instead of from left to right.</summary>
-        RightToLeft             = 0x0040, // "r"
-
-#if DEBUG
-        /// <summary>Enable Regex debugging.</summary>
-        Debug                   = 0x0080, // "d"
-#endif
+        RightToLeft             = 0x0040,
 
         /// <summary>Enable ECMAScript-compliant behavior for the expression.</summary>
-        ECMAScript              = 0x0100, // "e"
+        ECMAScript              = 0x0100,
 
         /// <summary>Ignore cultural differences in language.</summary>
         CultureInvariant        = 0x0200,
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs
index 9c7f8bdb3cc94b..b81e9d88e86b24 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs
@@ -1783,7 +1783,7 @@ private string ParseProperty()
             return capname;
         }
 
-        /// <summary>Returns ReNode type for zero-length assertions with a \ code.</summary>
+        /// <summary>Returns the node kind for zero-length assertions with a \ code.</summary>
         private RegexNodeKind TypeFromCode(char ch) =>
             ch switch
             {
@@ -1796,28 +1796,17 @@ private RegexNodeKind TypeFromCode(char ch) =>
                 _ => RegexNodeKind.Nothing,
             };
 
-        /// <summary>Returns option bit from single-char (?cimsx) code.</summary>
-        private static RegexOptions OptionFromCode(char ch)
-        {
-            // case-insensitive
-            if ((uint)(ch - 'A') <= 'Z' - 'A')
-            {
-                ch += (char)('a' - 'A');
-            }
-
-            return ch switch
+        /// <summary>Returns option bit from single-char (?imnsx) code.</summary>
+        private static RegexOptions OptionFromCode(char ch) =>
+            (char)(ch | 0x20) switch
             {
                 'i' => RegexOptions.IgnoreCase,
                 'm' => RegexOptions.Multiline,
                 'n' => RegexOptions.ExplicitCapture,
                 's' => RegexOptions.Singleline,
                 'x' => RegexOptions.IgnorePatternWhitespace,
-#if DEBUG
-                'd' => RegexOptions.Debug,
-#endif
-                _ => 0,
+                _ => RegexOptions.None,
             };
-        }
 
         /// <summary>
         /// A prescanner for deducing the slots used for captures by doing a partial tokenization of the pattern.
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexRunner.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexRunner.cs
index 15f33145b79838..13a9fbf155bb12 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexRunner.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexRunner.cs
@@ -145,16 +145,10 @@ protected RegexRunner() { }
             bool initialized = false;
             while (true)
             {
+                // Find the next potential location for a match in the input.
 #if DEBUG
-                if (regex.IsDebug)
-                {
-                    Debug.WriteLine("");
-                    Debug.WriteLine($"Search range: from {runtextbeg} to {runtextend}");
-                    Debug.WriteLine($"Firstchar search starting at {runtextpos} stopping at {stoppos}");
-                }
+                Debug.WriteLineIf(Regex.EnableDebugTracing, $"Calling FindFirstChar at {nameof(runtextbeg)}={runtextbeg}, {nameof(runtextpos)}={runtextpos}, {nameof(runtextend)}={runtextend}");
 #endif
-
-                // Find the next potential location for a match in the input.
                 if (FindFirstChar())
                 {
                     if (!ignoreTimeout)
@@ -170,15 +164,10 @@ protected RegexRunner() { }
                         initialized = true;
                     }
 
+                    // See if there's a match at this position.
 #if DEBUG
-                    if (regex.IsDebug)
-                    {
-                        Debug.WriteLine($"Executing engine starting at {runtextpos}");
-                        Debug.WriteLine("");
-                    }
+                    Debug.WriteLineIf(Regex.EnableDebugTracing, $"Calling Go at {nameof(runtextpos)}={runtextpos}");
 #endif
-
-                    // See if there's a match at this position.
                     Go();
 
                     // If we got a match, we're done.
@@ -264,16 +253,10 @@ internal void ScanInternal<TState>(Regex regex, string text, int textstart, ref
             bool initialized = false;
             while (true)
             {
+                // Find the next potential location for a match in the input.
 #if DEBUG
-                if (regex.IsDebug)
-                {
-                    Debug.WriteLine("");
-                    Debug.WriteLine($"Search range: from {runtextbeg} to {runtextend}");
-                    Debug.WriteLine($"Firstchar search starting at {runtextpos} stopping at {stoppos}");
-                }
+                Debug.WriteLineIf(Regex.EnableDebugTracing, $"Calling FindFirstChar at {nameof(runtextbeg)}={runtextbeg}, {nameof(runtextpos)}={runtextpos}, {nameof(runtextend)}={runtextend}");
 #endif
-
-                // Find the next potential location for a match in the input.
                 if (FindFirstChar())
                 {
                     if (!ignoreTimeout)
@@ -290,11 +273,7 @@ internal void ScanInternal<TState>(Regex regex, string text, int textstart, ref
                     }
 
 #if DEBUG
-                    if (regex.IsDebug)
-                    {
-                        Debug.WriteLine($"Executing engine starting at {runtextpos}");
-                        Debug.WriteLine("");
-                    }
+                    Debug.WriteLineIf(Regex.EnableDebugTracing, $"Calling Go at {nameof(runtextpos)}={runtextpos}");
 #endif
 
                     // See if there's a match at this position.
@@ -406,19 +385,6 @@ private void DoCheckTimeout()
             if (0 > _timeoutOccursAt && 0 < currentMillis)
                 return;
 
-#if DEBUG
-            if (runregex!.IsDebug)
-            {
-                Debug.WriteLine("");
-                Debug.WriteLine("RegEx match timeout occurred!");
-                Debug.WriteLine($"Specified timeout:       {TimeSpan.FromMilliseconds(_timeout)}");
-                Debug.WriteLine($"Timeout check frequency: {TimeoutCheckFrequency}");
-                Debug.WriteLine($"Search pattern:          {runregex.pattern}");
-                Debug.WriteLine($"Input:                   {runtext}");
-                Debug.WriteLine("About to throw RegexMatchTimeoutException.");
-            }
-#endif
-
             throw new RegexMatchTimeoutException(runtext!, runregex!.pattern!, TimeSpan.FromMilliseconds(_timeout));
         }
 
@@ -714,81 +680,77 @@ protected int MatchLength(int cap)
         /// Dump the current state
         /// </summary>
         [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        internal virtual void DumpState()
-        {
-            Debug.WriteLine($"Text:  {TextposDescription()}");
-            Debug.WriteLine($"Track: {StackDescription(runtrack!, runtrackpos)}");
-            Debug.WriteLine($"Stack: {StackDescription(runstack!, runstackpos)}");
-        }
-
-        [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        private static string StackDescription(int[] a, int index)
+        internal virtual void DebugTraceCurrentState()
         {
-            var sb = new StringBuilder();
-
-            sb.Append(a.Length - index);
-            sb.Append('/');
-            sb.Append(a.Length);
+            Debug.WriteLineIf(Regex.EnableDebugTracing, $"Text:  {DescribeTextPosition()}");
+            Debug.WriteLineIf(Regex.EnableDebugTracing, $"Track: {DescribeStack(runtrack!, runtrackpos)}");
+            Debug.WriteLineIf(Regex.EnableDebugTracing, $"Stack: {DescribeStack(runstack!, runstackpos)}");
 
-            if (sb.Length < 8)
+            string DescribeTextPosition()
             {
-                sb.Append(' ', 8 - sb.Length);
-            }
+                var sb = new StringBuilder();
 
-            sb.Append('(');
+                sb.Append(runtextpos);
 
-            for (int i = index; i < a.Length; i++)
-            {
-                if (i > index)
+                if (sb.Length < 8)
                 {
-                    sb.Append(' ');
+                    sb.Append(' ', 8 - sb.Length);
                 }
-                sb.Append(a[i]);
-            }
-
-            sb.Append(')');
 
-            return sb.ToString();
-        }
+                if (runtextpos > runtextbeg)
+                {
+                    sb.Append(RegexCharClass.DescribeChar(runtext![runtextpos - 1]));
+                }
+                else
+                {
+                    sb.Append('^');
+                }
 
-        [ExcludeFromCodeCoverage(Justification = "Debug only")]
-        internal virtual string TextposDescription()
-        {
-            var sb = new StringBuilder();
+                sb.Append('>');
 
-            sb.Append(runtextpos);
+                for (int i = runtextpos; i < runtextend; i++)
+                {
+                    sb.Append(RegexCharClass.DescribeChar(runtext![i]));
+                }
+                if (sb.Length >= 64)
+                {
+                    sb.Length = 61;
+                    sb.Append("...");
+                }
+                else
+                {
+                    sb.Append('$');
+                }
 
-            if (sb.Length < 8)
-            {
-                sb.Append(' ', 8 - sb.Length);
+                return sb.ToString();
             }
 
-            if (runtextpos > runtextbeg)
-            {
-                sb.Append(RegexCharClass.CharDescription(runtext![runtextpos - 1]));
-            }
-            else
+            static string DescribeStack(int[] stack, int index)
             {
-                sb.Append('^');
-            }
+                var sb = new StringBuilder();
 
-            sb.Append('>');
+                sb.Append(stack.Length - index).Append('/').Append(stack.Length);
 
-            for (int i = runtextpos; i < runtextend; i++)
-            {
-                sb.Append(RegexCharClass.CharDescription(runtext![i]));
-            }
-            if (sb.Length >= 64)
-            {
-                sb.Length = 61;
-                sb.Append("...");
-            }
-            else
-            {
-                sb.Append('$');
-            }
+                if (sb.Length < 8)
+                {
+                    sb.Append(' ', 8 - sb.Length);
+                }
 
-            return sb.ToString();
+                sb.Append('(');
+
+                for (int i = index; i < stack.Length; i++)
+                {
+                    if (i > index)
+                    {
+                        sb.Append(' ');
+                    }
+                    sb.Append(stack[i]);
+                }
+
+                sb.Append(')');
+
+                return sb.ToString();
+            }
         }
 #endif
     }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexTree.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexTree.cs
index c86d8f54c03370..2394cddeeecf7a 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexTree.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexTree.cs
@@ -1,14 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-// RegexTree is just a wrapper for a node tree with some
-// global information attached.
-
 using System.Collections;
-using System.Diagnostics.CodeAnalysis;
 
 namespace System.Text.RegularExpressions
 {
+    /// <summary>Wrapper for a node tree with additional information attached.</summary>
     internal sealed class RegexTree
     {
         public readonly RegexNode Root;
@@ -31,16 +28,5 @@ internal RegexTree(RegexNode root, Hashtable caps, int[] capNumList, int capTop,
             Options = options;
             MinRequiredLength = minRequiredLength;
         }
-
-#if DEBUG
-        [ExcludeFromCodeCoverage]
-        public void Dump() => Root.Dump();
-
-        [ExcludeFromCodeCoverage]
-        public override string ToString() => Root.ToString();
-
-        [ExcludeFromCodeCoverage]
-        public bool Debug => (Options & RegexOptions.Debug) != 0;
-#endif
     }
 }
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexWriter.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexWriter.cs
index 3a1da357d804a9..9fc977fce9587d 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexWriter.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexWriter.cs
@@ -46,23 +46,12 @@ private RegexWriter(Span<int> emittedSpan, Span<int> intStackSpan)
 
         /// <summary>
         /// This is the only function that should be called from outside.
-        /// It takes a RegexTree and creates a corresponding RegexCode.
+        /// It takes a <see cref="RegexTree"/> and creates a corresponding <see cref="RegexCode"/>.
         /// </summary>
         public static RegexCode Write(RegexTree tree, CultureInfo culture)
         {
-            var writer = new RegexWriter(stackalloc int[EmittedSize], stackalloc int[IntStackSize]);
-            RegexCode code = writer.RegexCodeFromRegexTree(tree, culture);
-            writer.Dispose();
-
-#if DEBUG
-            if (tree.Debug)
-            {
-                tree.Dump();
-                code.Dump();
-            }
-#endif
-
-            return code;
+            using var writer = new RegexWriter(stackalloc int[EmittedSize], stackalloc int[IntStackSize]);
+            return writer.RegexCodeFromRegexTree(tree, culture);
         }
 
         /// <summary>
@@ -102,7 +91,7 @@ public RegexCode RegexCodeFromRegexTree(RegexTree tree, CultureInfo culture)
 
             // Every written code begins with a lazy branch.  This will be back-patched
             // to point to the ending Stop after the whole expression has been written.
-            Emit(RegexCode.Lazybranch, 0);
+            Emit(RegexOpcode.Lazybranch, 0);
 
             // Emit every node.
             RegexNode curNode = tree.Root;
@@ -138,7 +127,7 @@ public RegexCode RegexCodeFromRegexTree(RegexTree tree, CultureInfo culture)
 
             // Patch the starting Lazybranch, emit the final Stop, and get the resulting code array.
             PatchJump(0, _emitted.Length);
-            Emit(RegexCode.Stop);
+            Emit(RegexOpcode.Stop);
             int[] emitted = _emitted.AsSpan().ToArray();
 
             // Convert the string table into an ordered string array.
@@ -166,37 +155,37 @@ private void PatchJump(int offset, int jumpDest)
         /// functions all run in two modes: they can emit code, or
         /// they can just count the size of the code.
         /// </summary>
-        private void Emit(int op)
+        private void Emit(RegexOpcode op)
         {
             if (RegexCode.OpcodeBacktracks(op))
             {
                 _trackCount++;
             }
 
-            _emitted.Append(op);
+            _emitted.Append((int)op);
         }
 
         /// <summary>Emits a one-argument operation.</summary>
-        private void Emit(int op, int opd1)
+        private void Emit(RegexOpcode op, int opd1)
         {
             if (RegexCode.OpcodeBacktracks(op))
             {
                 _trackCount++;
             }
 
-            _emitted.Append(op);
+            _emitted.Append((int)op);
             _emitted.Append(opd1);
         }
 
         /// <summary>Emits a two-argument operation.</summary>
-        private void Emit(int op, int opd1, int opd2)
+        private void Emit(RegexOpcode op, int opd1, int opd2)
         {
             if (RegexCode.OpcodeBacktracks(op))
             {
                 _trackCount++;
             }
 
-            _emitted.Append(op);
+            _emitted.Append((int)op);
             _emitted.Append(opd1);
             _emitted.Append(opd2);
         }
@@ -230,14 +219,14 @@ private int StringCode(string str)
         /// </summary>
         private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
         {
-            int bits = 0;
+            RegexOpcode bits = 0;
             if ((node.Options & RegexOptions.RightToLeft) != 0)
             {
-                bits |= RegexCode.Rtl;
+                bits |= RegexOpcode.RightToLeft;
             }
             if ((node.Options & RegexOptions.IgnoreCase) != 0)
             {
-                bits |= RegexCode.Ci;
+                bits |= RegexOpcode.CaseInsensitive;
             }
 
             switch (nodeType)
@@ -251,7 +240,7 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                     if (curIndex < node.ChildCount() - 1)
                     {
                         _intStack.Append(_emitted.Length);
-                        Emit(RegexCode.Lazybranch, 0);
+                        Emit(RegexOpcode.Lazybranch, 0);
                     }
                     break;
 
@@ -261,7 +250,7 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                         {
                             int lazyBranchPos = _intStack.Pop();
                             _intStack.Append(_emitted.Length);
-                            Emit(RegexCode.Goto, 0);
+                            Emit(RegexOpcode.Goto, 0);
                             PatchJump(lazyBranchPos, _emitted.Length);
                         }
                         else
@@ -278,11 +267,11 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                     switch (curIndex)
                     {
                         case 0:
-                            Emit(RegexCode.Setjump);
+                            Emit(RegexOpcode.Setjump);
                             _intStack.Append(_emitted.Length);
-                            Emit(RegexCode.Lazybranch, 0);
-                            Emit(RegexCode.Testref, RegexParser.MapCaptureNumber(node.M, _caps));
-                            Emit(RegexCode.Forejump);
+                            Emit(RegexOpcode.Lazybranch, 0);
+                            Emit(RegexOpcode.TestBackreference, RegexParser.MapCaptureNumber(node.M, _caps));
+                            Emit(RegexOpcode.Forejump);
                             break;
                     }
                     break;
@@ -294,9 +283,9 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                             {
                                 int Branchpos = _intStack.Pop();
                                 _intStack.Append(_emitted.Length);
-                                Emit(RegexCode.Goto, 0);
+                                Emit(RegexOpcode.Goto, 0);
                                 PatchJump(Branchpos, _emitted.Length);
-                                Emit(RegexCode.Forejump);
+                                Emit(RegexOpcode.Forejump);
                                 break;
                             }
                         case 1:
@@ -309,10 +298,10 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                     switch (curIndex)
                     {
                         case 0:
-                            Emit(RegexCode.Setjump);
-                            Emit(RegexCode.Setmark);
+                            Emit(RegexOpcode.Setjump);
+                            Emit(RegexOpcode.Setmark);
                             _intStack.Append(_emitted.Length);
-                            Emit(RegexCode.Lazybranch, 0);
+                            Emit(RegexOpcode.Lazybranch, 0);
                             break;
                     }
                     break;
@@ -321,16 +310,16 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                     switch (curIndex)
                     {
                         case 0:
-                            Emit(RegexCode.Getmark);
-                            Emit(RegexCode.Forejump);
+                            Emit(RegexOpcode.Getmark);
+                            Emit(RegexOpcode.Forejump);
                             break;
                         case 1:
                             int Branchpos = _intStack.Pop();
                             _intStack.Append(_emitted.Length);
-                            Emit(RegexCode.Goto, 0);
+                            Emit(RegexOpcode.Goto, 0);
                             PatchJump(Branchpos, _emitted.Length);
-                            Emit(RegexCode.Getmark);
-                            Emit(RegexCode.Forejump);
+                            Emit(RegexOpcode.Getmark);
+                            Emit(RegexOpcode.Forejump);
                             break;
                         case 2:
                             PatchJump(_intStack.Pop(), _emitted.Length);
@@ -342,14 +331,14 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                 case RegexNodeKind.Lazyloop | BeforeChild:
 
                     if (node.N < int.MaxValue || node.M > 1)
-                        Emit(node.M == 0 ? RegexCode.Nullcount : RegexCode.Setcount, node.M == 0 ? 0 : 1 - node.M);
+                        Emit(node.M == 0 ? RegexOpcode.Nullcount : RegexOpcode.Setcount, node.M == 0 ? 0 : 1 - node.M);
                     else
-                        Emit(node.M == 0 ? RegexCode.Nullmark : RegexCode.Setmark);
+                        Emit(node.M == 0 ? RegexOpcode.Nullmark : RegexOpcode.Setmark);
 
                     if (node.M == 0)
                     {
                         _intStack.Append(_emitted.Length);
-                        Emit(RegexCode.Goto, 0);
+                        Emit(RegexOpcode.Goto, 0);
                     }
                     _intStack.Append(_emitted.Length);
                     break;
@@ -361,9 +350,9 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                         int Lazy = (nodeType - (RegexNodeKind.Loop | AfterChild));
 
                         if (node.N < int.MaxValue || node.M > 1)
-                            Emit(RegexCode.Branchcount + Lazy, _intStack.Pop(), node.N == int.MaxValue ? int.MaxValue : node.N - node.M);
+                            Emit(RegexOpcode.Branchcount + Lazy, _intStack.Pop(), node.N == int.MaxValue ? int.MaxValue : node.N - node.M);
                         else
-                            Emit(RegexCode.Branchmark + Lazy, _intStack.Pop());
+                            Emit(RegexOpcode.Branchmark + Lazy, _intStack.Pop());
 
                         if (node.M == 0)
                             PatchJump(_intStack.Pop(), StartJumpPos);
@@ -375,46 +364,46 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                     break;
 
                 case RegexNodeKind.Capture | BeforeChild:
-                    Emit(RegexCode.Setmark);
+                    Emit(RegexOpcode.Setmark);
                     break;
 
                 case RegexNodeKind.Capture | AfterChild:
-                    Emit(RegexCode.Capturemark, RegexParser.MapCaptureNumber(node.M, _caps), RegexParser.MapCaptureNumber(node.N, _caps));
+                    Emit(RegexOpcode.Capturemark, RegexParser.MapCaptureNumber(node.M, _caps), RegexParser.MapCaptureNumber(node.N, _caps));
                     break;
 
                 case RegexNodeKind.PositiveLookaround | BeforeChild:
-                    Emit(RegexCode.Setjump); // causes lookahead/lookbehind to be non-backtracking
-                    Emit(RegexCode.Setmark);
+                    Emit(RegexOpcode.Setjump); // causes lookahead/lookbehind to be non-backtracking
+                    Emit(RegexOpcode.Setmark);
                     break;
 
                 case RegexNodeKind.PositiveLookaround | AfterChild:
-                    Emit(RegexCode.Getmark);
-                    Emit(RegexCode.Forejump); // causes lookahead/lookbehind to be non-backtracking
+                    Emit(RegexOpcode.Getmark);
+                    Emit(RegexOpcode.Forejump); // causes lookahead/lookbehind to be non-backtracking
                     break;
 
                 case RegexNodeKind.NegativeLookaround | BeforeChild:
-                    Emit(RegexCode.Setjump);
+                    Emit(RegexOpcode.Setjump);
                     _intStack.Append(_emitted.Length);
-                    Emit(RegexCode.Lazybranch, 0);
+                    Emit(RegexOpcode.Lazybranch, 0);
                     break;
 
                 case RegexNodeKind.NegativeLookaround | AfterChild:
-                    Emit(RegexCode.Backjump);
+                    Emit(RegexOpcode.Backjump);
                     PatchJump(_intStack.Pop(), _emitted.Length);
-                    Emit(RegexCode.Forejump);
+                    Emit(RegexOpcode.Forejump);
                     break;
 
                 case RegexNodeKind.Atomic | BeforeChild:
-                    Emit(RegexCode.Setjump);
+                    Emit(RegexOpcode.Setjump);
                     break;
 
                 case RegexNodeKind.Atomic | AfterChild:
-                    Emit(RegexCode.Forejump);
+                    Emit(RegexOpcode.Forejump);
                     break;
 
                 case RegexNodeKind.One:
                 case RegexNodeKind.Notone:
-                    Emit((int)node.Kind | bits, node.Ch);
+                    Emit((RegexOpcode)node.Kind | bits, node.Ch);
                     break;
 
                 case RegexNodeKind.Notoneloop:
@@ -426,11 +415,11 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                     if (node.M > 0)
                     {
                         Emit(((node.Kind is RegexNodeKind.Oneloop or RegexNodeKind.Oneloopatomic or RegexNodeKind.Onelazy) ?
-                              RegexCode.Onerep : RegexCode.Notonerep) | bits, node.Ch, node.M);
+                              RegexOpcode.Onerep : RegexOpcode.Notonerep) | bits, node.Ch, node.M);
                     }
                     if (node.N > node.M)
                     {
-                        Emit((int)node.Kind | bits, node.Ch, node.N == int.MaxValue ? int.MaxValue : node.N - node.M);
+                        Emit((RegexOpcode)node.Kind | bits, node.Ch, node.N == int.MaxValue ? int.MaxValue : node.N - node.M);
                     }
                     break;
 
@@ -441,25 +430,25 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                         int stringCode = StringCode(node.Str!);
                         if (node.M > 0)
                         {
-                            Emit(RegexCode.Setrep | bits, stringCode, node.M);
+                            Emit(RegexOpcode.Setrep | bits, stringCode, node.M);
                         }
                         if (node.N > node.M)
                         {
-                            Emit((int)node.Kind | bits, stringCode, (node.N == int.MaxValue) ? int.MaxValue : node.N - node.M);
+                            Emit((RegexOpcode)node.Kind | bits, stringCode, (node.N == int.MaxValue) ? int.MaxValue : node.N - node.M);
                         }
                     }
                     break;
 
                 case RegexNodeKind.Multi:
-                    Emit((int)node.Kind | bits, StringCode(node.Str!));
+                    Emit((RegexOpcode)node.Kind | bits, StringCode(node.Str!));
                     break;
 
                 case RegexNodeKind.Set:
-                    Emit((int)node.Kind | bits, StringCode(node.Str!));
+                    Emit((RegexOpcode)node.Kind | bits, StringCode(node.Str!));
                     break;
 
                 case RegexNodeKind.Backreference:
-                    Emit((int)node.Kind | bits, RegexParser.MapCaptureNumber(node.M, _caps));
+                    Emit((RegexOpcode)node.Kind | bits, RegexParser.MapCaptureNumber(node.M, _caps));
                     break;
 
                 case RegexNodeKind.Nothing:
@@ -474,7 +463,7 @@ private void EmitFragment(RegexNodeKind nodeType, RegexNode node, int curIndex)
                 case RegexNodeKind.EndZ:
                 case RegexNodeKind.End:
                 case RegexNodeKind.UpdateBumpalong:
-                    Emit((int)node.Kind);
+                    Emit((RegexOpcode)node.Kind);
                     break;
 
                 default:

From 9378f8d929d064a5a84265b255aac308d85ada0e Mon Sep 17 00:00:00 2001
From: Jo Shields <directhex@apebox.org>
Date: Thu, 27 Jan 2022 11:28:47 -0500
Subject: [PATCH 109/161] Run Pi tests on a different queue, which runs ARM32
 tests (#64353)

I blogged about the negative performance implications of this in 2019 (CP15 memory barriers are emulated on ARMv8 kernels, and issue an all-core pipeline flush and ~1000 cycle penalty; the performance loss scales exponentially with the number of cores in the system)
---
 eng/pipelines/libraries/helix-queues-setup.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml
index 70161eb7e19684..f82e09c9e0a124 100644
--- a/eng/pipelines/libraries/helix-queues-setup.yml
+++ b/eng/pipelines/libraries/helix-queues-setup.yml
@@ -36,7 +36,7 @@ jobs:
     # Linux armv6
     - ${{ if eq(parameters.platform, 'Linux_armv6') }}:
 #      - ${{ if eq(parameters.jobParameters.isFullMatrix, true) }}:
-      - (Raspbian.10.Armv6.Open)Raspbian.9.Arm32.IoT.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:raspbian-10-helix-arm32v6-20211215185610-60748cc
+      - (Raspbian.10.Armv6.Open)Ubuntu.1804.ArmArch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:raspbian-10-helix-arm32v6-20211215185610-60748cc
 
     # Linux arm64
     - ${{ if eq(parameters.platform, 'Linux_arm64') }}:

From 372b0891396f1d91633375e2fb50f693a1506684 Mon Sep 17 00:00:00 2001
From: Zoltan Varga <vargaz@gmail.com>
Date: Thu, 27 Jan 2022 12:02:26 -0500
Subject: [PATCH 110/161] [mono] Avoid inlining the wrappers used by CALLI.
 (#64290)

They contain an LMF and the inlining removes it.

Fixes https://github.com/dotnet/runtime/issues/64073.
---
 src/mono/mono/metadata/marshal.c  |  4 +++-
 src/mono/mono/metadata/marshal.h  |  7 +++++++
 src/mono/mono/mini/aot-compiler.c |  5 +++++
 src/mono/mono/mini/aot-runtime.c  | 12 +++++++++++-
 src/mono/mono/mini/aot-runtime.h  |  2 +-
 src/mono/mono/mini/method-to-ir.c | 12 +-----------
 6 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/src/mono/mono/metadata/marshal.c b/src/mono/mono/metadata/marshal.c
index 491fdcc2b9fc06..8db72b61d9da91 100644
--- a/src/mono/mono/metadata/marshal.c
+++ b/src/mono/mono/metadata/marshal.c
@@ -3803,7 +3803,9 @@ mono_marshal_get_native_func_wrapper_indirect (MonoClass *caller_class, MonoMeth
 	mb->method->save_lmf = 1;
 
 	WrapperInfo *info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_NATIVE_FUNC_INDIRECT);
-	info->d.managed_to_native.method = NULL;
+	//info->d.managed_to_native.method = NULL;
+	info->d.native_func.klass = caller_class;
+	info->d.native_func.sig = sig;
 
 	MonoMethodPInvoke *piinfo = NULL;
 	MonoMarshalSpec **mspecs = g_new0 (MonoMarshalSpec *, 1 + sig->param_count);
diff --git a/src/mono/mono/metadata/marshal.h b/src/mono/mono/metadata/marshal.h
index 3d35ee3abf75d0..91bab1c8978aa4 100644
--- a/src/mono/mono/metadata/marshal.h
+++ b/src/mono/mono/metadata/marshal.h
@@ -233,6 +233,11 @@ typedef struct {
 	MonoLLVMFuncWrapperSubtype subtype;
 } LLVMFuncWrapperInfo;
 
+typedef struct {
+	MonoClass *klass;
+	MonoMethodSignature *sig;
+} NativeFuncWrapperInfo;
+
 /*
  * This structure contains additional information to uniquely identify a given wrapper
  * method. It can be retrieved by mono_marshal_get_wrapper_info () for certain types
@@ -277,6 +282,8 @@ typedef struct {
 		AOTInitWrapperInfo aot_init;
 		/* LLVM_FUNC */
 		LLVMFuncWrapperInfo llvm_func;
+		/* NATIVE_FUNC_INDIRECT */
+		NativeFuncWrapperInfo native_func;
 	} d;
 } WrapperInfo;
 
diff --git a/src/mono/mono/mini/aot-compiler.c b/src/mono/mono/mini/aot-compiler.c
index 4a3ca8efe039c1..7bc376cd3bf56b 100644
--- a/src/mono/mono/mini/aot-compiler.c
+++ b/src/mono/mono/mini/aot-compiler.c
@@ -3671,6 +3671,8 @@ encode_signature (MonoAotCompile *acfg, MonoMethodSignature *sig, guint8 *buf, g
 		flags |= 0x20;
 	if (sig->explicit_this)
 		flags |= 0x40;
+	if (sig->pinvoke)
+		flags |= 0x80;
 	flags |= (sig->call_convention & 0x0F);
 
 	*p = flags;
@@ -3772,6 +3774,9 @@ encode_method_ref (MonoAotCompile *acfg, MonoMethod *method, guint8 *buf, guint8
 				encode_value (info->d.icall.jit_icall_id, p, &p);
 			} else if (info->subtype == WRAPPER_SUBTYPE_NATIVE_FUNC_AOT) {
 				encode_method_ref (acfg, info->d.managed_to_native.method, p, &p);
+			} else if (info->subtype == WRAPPER_SUBTYPE_NATIVE_FUNC_INDIRECT) {
+				encode_klass_ref (acfg, info->d.native_func.klass, p, &p);
+				encode_signature (acfg, info->d.native_func.sig, p, &p);
 			} else {
 				g_assert (info->subtype == WRAPPER_SUBTYPE_NONE || info->subtype == WRAPPER_SUBTYPE_PINVOKE);
 				encode_method_ref (acfg, info->d.managed_to_native.method, p, &p);
diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c
index cddb53c8649b48..4bfbd295199778 100644
--- a/src/mono/mono/mini/aot-runtime.c
+++ b/src/mono/mono/mini/aot-runtime.c
@@ -840,13 +840,14 @@ decode_signature_with_target (MonoAotModule *module, MonoMethodSignature *target
 	guint32 flags;
 	int i, gen_param_count = 0, param_count, call_conv;
 	guint8 *p = buf;
-	gboolean hasthis, explicit_this, has_gen_params;
+	gboolean hasthis, explicit_this, has_gen_params, pinvoke;
 
 	flags = *p;
 	p ++;
 	has_gen_params = (flags & 0x10) != 0;
 	hasthis = (flags & 0x20) != 0;
 	explicit_this = (flags & 0x40) != 0;
+	pinvoke = (flags & 0x80) != 0;
 	call_conv = flags & 0x0F;
 
 	if (has_gen_params)
@@ -859,6 +860,7 @@ decode_signature_with_target (MonoAotModule *module, MonoMethodSignature *target
 	sig->sentinelpos = -1;
 	sig->hasthis = hasthis;
 	sig->explicit_this = explicit_this;
+	sig->pinvoke = pinvoke;
 	sig->call_convention = call_conv;
 	sig->generic_param_count = gen_param_count;
 	sig->ret = decode_type (module, p, &p, error);
@@ -1127,6 +1129,14 @@ decode_method_ref_with_target (MonoAotModule *module, MethodRef *ref, MonoMethod
 			if (subtype == WRAPPER_SUBTYPE_ICALL_WRAPPER) {
 				MonoJitICallInfo *info = mono_find_jit_icall_info ((MonoJitICallId)decode_value (p, &p));
 				ref->method = mono_icall_get_wrapper_method (info);
+			} else if (subtype == WRAPPER_SUBTYPE_NATIVE_FUNC_INDIRECT) {
+				MonoClass *klass = decode_klass_ref (module, p, &p, error);
+				if (!klass)
+					return FALSE;
+				MonoMethodSignature *sig = decode_signature (module, p, &p);
+				if (!sig)
+					return FALSE;
+				ref->method = mono_marshal_get_native_func_wrapper_indirect (klass, sig, TRUE);
 			} else {
 				m = decode_resolve_method_ref (module, p, &p, error);
 				if (!m)
diff --git a/src/mono/mono/mini/aot-runtime.h b/src/mono/mono/mini/aot-runtime.h
index dff55a92563faa..4cb34374fe08ba 100644
--- a/src/mono/mono/mini/aot-runtime.h
+++ b/src/mono/mono/mini/aot-runtime.h
@@ -11,7 +11,7 @@
 #include "mini.h"
 
 /* Version number of the AOT file format */
-#define MONO_AOT_FILE_VERSION 182
+#define MONO_AOT_FILE_VERSION 183
 
 #define MONO_AOT_TRAMP_PAGE_SIZE 16384
 
diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c
index 7a5f5db4fab6e8..d1a1e91ed21d70 100644
--- a/src/mono/mono/mini/method-to-ir.c
+++ b/src/mono/mono/mini/method-to-ir.c
@@ -7214,17 +7214,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
 
 					g_assert (!fsig->hasthis && !fsig->pinvoke);
 
-					gboolean inline_wrapper = cfg->opt & MONO_OPT_INLINE || cfg->compile_aot;
-					if (inline_wrapper) {
-						int costs = inline_method (cfg, wrapper, fsig, sp, ip, cfg->real_offset, TRUE, NULL);
-						CHECK_CFG_EXCEPTION;
-						g_assert (costs > 0);
-						cfg->real_offset += 5;
-						inline_costs += costs;
-						ins = sp[0];
-					} else {
-						ins = mono_emit_method_call (cfg, wrapper, /*args*/sp, NULL);
-					}
+					ins = mono_emit_method_call (cfg, wrapper, /*args*/sp, NULL);
 					goto calli_end;
 				}
 			}

From b0de7ba0690c7b40f4d2b536fdd8fe588fed09f9 Mon Sep 17 00:00:00 2001
From: Egor Bogatov <egorbo@gmail.com>
Date: Thu, 27 Jan 2022 20:04:02 +0300
Subject: [PATCH 111/161] JIT: Clone ADDR(LCL) for DUP (#64171)

---
 src/coreclr/jit/compiler.h   |  2 +-
 src/coreclr/jit/gentree.cpp  |  3 +--
 src/coreclr/jit/importer.cpp | 44 ++++++++++++++++++++++++++++--------
 3 files changed, 37 insertions(+), 12 deletions(-)

diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
index 6b30adbacb121d..ba19b8445afbff 100644
--- a/src/coreclr/jit/compiler.h
+++ b/src/coreclr/jit/compiler.h
@@ -4844,7 +4844,7 @@ class Compiler
     static LONG jitNestingLevel;
 #endif // DEBUG
 
-    static bool impIsAddressInLocal(const GenTree* tree, GenTree** lclVarTreeOut);
+    static bool impIsAddressInLocal(const GenTree* tree, GenTree** lclVarTreeOut = nullptr);
 
     void impMakeDiscretionaryInlineObservations(InlineInfo* pInlineInfo, InlineResult* inlineResult);
 
diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index 23c9d1a0f149b6..35b9d2d829ca42 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -22025,8 +22025,7 @@ bool GenTreeLclFld::IsOffsetMisaligned() const
 
 bool GenTree::IsInvariant() const
 {
-    GenTree* lclVarTree = nullptr;
-    return OperIsConst() || Compiler::impIsAddressInLocal(this, &lclVarTree);
+    return OperIsConst() || Compiler::impIsAddressInLocal(this);
 }
 
 //------------------------------------------------------------------------
diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp
index 648b4a8493d2f7..9668b22c5ebf87 100644
--- a/src/coreclr/jit/importer.cpp
+++ b/src/coreclr/jit/importer.cpp
@@ -2646,11 +2646,9 @@ inline void Compiler::impSpillSideEffects(bool spillGlobEffects, unsigned chkLev
     {
         GenTree* tree = verCurrentState.esStack[i].val;
 
-        GenTree* lclVarTree;
-
         if ((tree->gtFlags & spillFlags) != 0 ||
-            (spillGlobEffects &&                        // Only consider the following when  spillGlobEffects == true
-             !impIsAddressInLocal(tree, &lclVarTree) && // No need to spill the GT_ADDR node on a local.
+            (spillGlobEffects &&           // Only consider the following when  spillGlobEffects == true
+             !impIsAddressInLocal(tree) && // No need to spill the GT_ADDR node on a local.
              gtHasLocalsWithAddrOp(tree))) // Spill if we still see GT_LCL_VAR that contains lvHasLdAddrOp or
                                            // lvAddrTaken flag.
         {
@@ -14411,15 +14409,40 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     impStackTop(0);
                 }
 
-                // If the expression to dup is simple, just clone it.
-                // Otherwise spill it to a temp, and reload the temp
-                // twice.
                 StackEntry se   = impPopStack();
                 GenTree*   tree = se.val;
                 tiRetVal        = se.seTypeInfo;
                 op1             = tree;
 
-                if (!opts.compDbgCode && !op1->IsIntegralConst(0) && !op1->IsFPZero() && !op1->IsLocal())
+                // If the expression to dup is simple, just clone it.
+                // Otherwise spill it to a temp, and reload the temp twice.
+                bool cloneExpr = false;
+
+                if (!opts.compDbgCode)
+                {
+                    // Duplicate 0 and +0.0
+                    if (op1->IsIntegralConst(0) || op1->IsFloatPositiveZero())
+                    {
+                        cloneExpr = true;
+                    }
+                    // Duplicate locals and addresses of them
+                    else if (op1->IsLocal())
+                    {
+                        cloneExpr = true;
+                    }
+                    else if (op1->TypeIs(TYP_BYREF) && op1->OperIs(GT_ADDR) && op1->gtGetOp1()->IsLocal() &&
+                             (OPCODE)impGetNonPrefixOpcode(codeAddr + sz, codeEndp) != CEE_INITOBJ)
+                    {
+                        cloneExpr = true;
+                    }
+                }
+                else
+                {
+                    // Always clone for debug mode
+                    cloneExpr = true;
+                }
+
+                if (!cloneExpr)
                 {
                     const unsigned tmpNum = lvaGrabTemp(true DEBUGARG("dup spill"));
                     impAssignTempGen(tmpNum, op1, tiRetVal.GetClassHandle(), (unsigned)CHECK_SPILL_ALL);
@@ -19555,7 +19578,10 @@ bool Compiler::impIsAddressInLocal(const GenTree* tree, GenTree** lclVarTreeOut)
 
     if (op->gtOper == GT_LCL_VAR)
     {
-        *lclVarTreeOut = op;
+        if (lclVarTreeOut != nullptr)
+        {
+            *lclVarTreeOut = op;
+        }
         return true;
     }
     else

From cfd15d5fe962717d63b77ad0e29ce2aff9a0f847 Mon Sep 17 00:00:00 2001
From: imhameed <imhameed@microsoft.com>
Date: Thu, 27 Jan 2022 12:07:16 -0500
Subject: [PATCH 112/161] [mono] Always store to allocas in OP_LLVM_OUTARG_VT
 (#64303)

OP_LLVM_OUTARG_VT will, for some argument passing conventions, create an
alloca and mirror its source SSA value into this alloca. If such an
OP_LLVM_OUTARG_VT is first encountered in a basic block that does not
contain the definition of the SSA value being mirrored, then sibling
basic blocks (e.g. a loop body that may sometimes be skipped) can use
garbage data if they also have OP_LLVM_OUTARG_VT opcodes referring to
the same SSA values.

This commit works around this by unconditionally storing the source
OP_LLVM_OUTARG_VT value into its associated alloca. The resulting IR
would be a little easier to read if we eagerly stored to an alloca
mirror exactly once at each value's definition, but that would require
more work to implement.

Fixes JIT/SIMD/VectorExp_ro/VectorExp_ro. See https://github.com/dotnet/runtime/issues/64179.
---
 src/mono/mono/mini/mini-llvm.c | 7 ++++++-
 src/tests/issues.targets       | 3 ---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c
index cd6a279c223d80..c222a8d80c76aa 100644
--- a/src/mono/mono/mini/mini-llvm.c
+++ b/src/mono/mono/mini/mini-llvm.c
@@ -7486,7 +7486,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 				addresses [ins->dreg] = addresses [ins->sreg1];
 			} else {
 				if (!addresses [ins->sreg1]) {
-					addresses [ins->sreg1] = build_alloca (ctx, t);
+					addresses [ins->sreg1] = build_named_alloca (ctx, t, "llvm_outarg_vt");
 					g_assert (values [ins->sreg1]);
 					LLVMBuildStore (builder, convert (ctx, values [ins->sreg1], type_to_llvm_type (ctx, t)), addresses [ins->sreg1]);
 					addresses [ins->dreg] = addresses [ins->sreg1];
@@ -7496,6 +7496,11 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
 					LLVMValueRef v = LLVMBuildLoad (builder, addresses [ins->sreg1], "llvm_outarg_vt_copy");
 					LLVMBuildStore (builder, convert (ctx, v, type_to_llvm_type (ctx, t)), addresses [ins->dreg]);
 				} else {
+					if (values [ins->sreg1]) {
+						LLVMTypeRef src_t = LLVMTypeOf (values [ins->sreg1]);
+						LLVMValueRef dst = convert (ctx, addresses [ins->sreg1], LLVMPointerType (src_t, 0));
+						LLVMBuildStore (builder, values [ins->sreg1], dst);
+					}
 					addresses [ins->dreg] = addresses [ins->sreg1];
 				}
 			}
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index 78089a05600769..7de0a388786697 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -2803,9 +2803,6 @@
         <ExcludeList Include="$(XunitTestBinBase)/JIT/HardwareIntrinsics/Arm/ArmBase/Yield_*/**">
             <Issue>https://github.com/dotnet/runtime/issues/64179</Issue>
         </ExcludeList>
-        <ExcludeList Include="$(XunitTestBinBase)/JIT/SIMD/VectorExp_*/**">
-            <Issue>https://github.com/dotnet/runtime/issues/64179</Issue>
-        </ExcludeList>
     </ItemGroup>
 
     <ItemGroup Condition="'$(RuntimeFlavor)' == 'mono' and ('$(RuntimeVariant)' == 'llvmfullaot' or '$(RuntimeVariant)' == 'llvmaot')">

From 20744776437ab483b3e68d608996fdcf1b02420b Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Thu, 27 Jan 2022 19:21:12 +0100
Subject: [PATCH 113/161] Remove some of the unused resource strings (#64379)

---
 .../Common/tests/Resources/Strings.resx       |  9 ---
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  4 -
 .../src/Resources/Strings.resx                |  6 --
 .../src/Resources/Strings.resx                | 21 -----
 .../src/Resources/Strings.resx                |  9 ---
 .../src/Resources/Strings.resx                |  5 +-
 .../src/Resources/Strings.resx                |  1 -
 .../src/Resources/Strings.resx                |  6 --
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  6 --
 .../src/Resources/Strings.resx                |  5 +-
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                | 78 ------------------
 .../src/Resources/Strings.resx                | 69 ----------------
 .../src/Resources/Strings.resx                |  9 ---
 .../src/Resources/Strings.resx                | 41 +---------
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  9 ---
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                | 21 -----
 .../System.Memory/src/Resources/Strings.resx  |  3 -
 .../src/Resources/Strings.resx                | 30 -------
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  6 --
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                | 80 +------------------
 .../FunctionalTests/Resources/Strings.resx    |  9 ---
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                | 15 ----
 .../src/Resources/Strings.resx                |  9 ---
 .../src/Resources/Strings.resx                | 18 -----
 .../src/Resources/Strings.resx                | 21 -----
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                | 30 -------
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                | 24 ------
 .../src/Resources/Strings.resx                | 24 ------
 .../src/Resources/Strings.resx                | 39 ---------
 .../tests/Resources/Strings.resx              | 78 ------------------
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  6 --
 .../gen/Resources/Strings.resx                |  6 --
 .../gen/Resources/xlf/Strings.cs.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.de.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.es.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.fr.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.it.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.ja.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.ko.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.pl.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.pt-BR.xlf       | 10 ---
 .../gen/Resources/xlf/Strings.ru.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.tr.xlf          | 10 ---
 .../gen/Resources/xlf/Strings.zh-Hans.xlf     | 10 ---
 .../gen/Resources/xlf/Strings.zh-Hant.xlf     | 10 ---
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  3 -
 60 files changed, 4 insertions(+), 868 deletions(-)

diff --git a/src/libraries/Common/tests/Resources/Strings.resx b/src/libraries/Common/tests/Resources/Strings.resx
index 1673683936a79a..7d48d2b4fe49d5 100644
--- a/src/libraries/Common/tests/Resources/Strings.resx
+++ b/src/libraries/Common/tests/Resources/Strings.resx
@@ -156,9 +156,6 @@
   <data name="IO_PathTooLong_Path" xml:space="preserve">
     <value>IO_PathTooLong_Path {0}</value>
   </data>
-  <data name="Arg_InvalidSearchPattern" xml:space="preserve">
-    <value>Arg_InvalidSearchPattern {0}</value>
-  </data>
   <data name="Argv_IncludeDoubleQuote" xml:space="preserve">
     <value>The argv[0] argument cannot include a double quote.</value>
   </data>
@@ -168,9 +165,6 @@
   <data name="net_http_hpack_bad_integer" xml:space="preserve">
     <value>HPACK integer exceeds limits or has an overlong encoding.</value>
   </data>
-  <data name="net_http_hpack_encode_failure" xml:space="preserve">
-    <value>Failed to HPACK encode the headers.</value>
-  </data>
   <data name="net_http_hpack_huffman_decode_failed" xml:space="preserve">
     <value>Huffman-coded literal string failed to decode.</value>
   </data>
@@ -201,9 +195,6 @@
   <data name="net_quic_connectionaborted" xml:space="preserve">
     <value>Connection aborted by peer ({0}).</value>
   </data>
-  <data name="net_quic_notsupported" xml:space="preserve">
-    <value>QUIC is not supported on this platform. See https://aka.ms/dotnetquic</value>
-  </data>
   <data name="net_quic_operationaborted" xml:space="preserve">
     <value>Operation aborted.</value>
   </data>
diff --git a/src/libraries/Microsoft.Diagnostics.Tracing.EventSource.Redist/src/Resources/Strings.resx b/src/libraries/Microsoft.Diagnostics.Tracing.EventSource.Redist/src/Resources/Strings.resx
index bf2f61e56bdc21..0e3913b9ba776f 100644
--- a/src/libraries/Microsoft.Diagnostics.Tracing.EventSource.Redist/src/Resources/Strings.resx
+++ b/src/libraries/Microsoft.Diagnostics.Tracing.EventSource.Redist/src/Resources/Strings.resx
@@ -272,9 +272,6 @@
   <data name="EventSource_RecursiveTypeDefinition" xml:space="preserve">
     <value>Recursive type definition is not supported.</value>
   </data>
-  <data name="EventSource_SessionIdError" xml:space="preserve">
-    <value>Bit position in AllKeywords ({0}) must equal the command argument named "EtwSessionKeyword" ({1}).</value>
-  </data>
   <data name="EventSource_StopsFollowStarts" xml:space="preserve">
     <value>An event with stop suffix must follow a corresponding event with a start suffix.</value>
   </data>
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/Resources/Strings.resx b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/Resources/Strings.resx
index 9f74883c8e8ec6..f6d5587b1d7231 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/Resources/Strings.resx
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/Resources/Strings.resx
@@ -121,10 +121,6 @@
     <value>Multiple constructors accepting all given argument types have been found in type '{0}'. There should only be one applicable constructor.</value>
     <comment>{0} = service type</comment>
   </data>
-  <data name="CannotLocateImplementation" xml:space="preserve">
-    <value>Unable to locate implementation '{0}' for service '{1}'.</value>
-    <comment>{0} = implementation type, {1} = service type</comment>
-  </data>
   <data name="CannotResolveService" xml:space="preserve">
     <value>Unable to resolve service for type '{0}' while attempting to activate '{1}'.</value>
     <comment>{0} = service which cannot be resolved, {1} = service being activated</comment>
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/src/Resources/Strings.resx b/src/libraries/Microsoft.Win32.SystemEvents/src/Resources/Strings.resx
index 96464aac30db8c..bb14b9a2d94d6c 100644
--- a/src/libraries/Microsoft.Win32.SystemEvents/src/Resources/Strings.resx
+++ b/src/libraries/Microsoft.Win32.SystemEvents/src/Resources/Strings.resx
@@ -122,15 +122,9 @@
   <data name="ErrorCreateTimer" xml:space="preserve">
     <value>Cannot create timer.</value>
   </data>
-  <data name="ErrorGetTempPath" xml:space="preserve">
-    <value>Cannot get temporary file name</value>
-  </data>
   <data name="ErrorKillTimer" xml:space="preserve">
     <value>Cannot end timer.</value>
   </data>
-  <data name="ErrorSystemEventsNotSupported" xml:space="preserve">
-    <value>System event notifications are not supported under the current context. Server processes, for example, may not support global system event notifications.</value>
-  </data>
   <data name="InvalidLowBoundArgument" xml:space="preserve">
     <value>'{1}' is not a valid value for '{0}'. '{0}' must be greater than {2}.</value>
   </data>
diff --git a/src/libraries/System.ComponentModel.Composition/src/Resources/Strings.resx b/src/libraries/System.ComponentModel.Composition/src/Resources/Strings.resx
index 8899ffb3aab230..683d709992edbe 100644
--- a/src/libraries/System.ComponentModel.Composition/src/Resources/Strings.resx
+++ b/src/libraries/System.ComponentModel.Composition/src/Resources/Strings.resx
@@ -72,9 +72,6 @@
   <data name="Argument_NullElement" xml:space="preserve">
     <value>'{0}' cannot contain a null (Nothing in Visual Basic) element.</value>
   </data>
-  <data name="AssemblyFileNotFoundOrWrongType" xml:space="preserve">
-    <value>Assembly file {0} is either not found or not a dll or exe file.</value>
-  </data>
   <data name="CardinalityMismatch_NoExports" xml:space="preserve">
     <value>No exports were found that match the constraint: {0}</value>
   </data>
@@ -129,12 +126,6 @@
   <data name="InvalidMetadataView" xml:space="preserve">
     <value>The Type '{0}' supplied is not a valid Metadata View.</value>
   </data>
-  <data name="InvalidOperationReentrantCompose" xml:space="preserve">
-    <value>A call to Compose occurred during a call to Compose on the same CompositionContainer object. Use the IsComposing property on CompositionContainer to ensure a composition is not already in progress before calling Compose.</value>
-  </data>
-  <data name="MetadataItemNotSupported" xml:space="preserve">
-    <value>This export does not support the metadata item '{0}'.</value>
-  </data>
   <data name="NotSupportedInterfaceMetadataView" xml:space="preserve">
     <value>Interface '{0}' is not a valid MetadataView; MetadataViews do not support non-public interfaces, and interfaces that contain members that are not properties.</value>
   </data>
@@ -144,9 +135,6 @@
   <data name="NotImplemented_NotOverriddenByDerived" xml:space="preserve">
     <value>The {0} member must be overridden by a derived class.</value>
   </data>
-  <data name="NotSupportedReadOnlyDictionary" xml:space="preserve">
-    <value>The underlying dictionary is read-only.</value>
-  </data>
   <data name="ObjectAlreadyInitialized" xml:space="preserve">
     <value>This property cannot be set after the object's public surface has been accessed.</value>
   </data>
@@ -357,9 +345,6 @@
   <data name="CompositionTrace_Discovery_DefinitionMismatchedExportArity" xml:space="preserve">
     <value>The composable part definition '{0}' was ignored because the export '{1}' has different generic parameters than the part type.</value>
   </data>
-  <data name="InvalidArgument_ReflectionContext" xml:space="preserve">
-    <value>'reflectionContext' must be a type that is assignable from System.Reflection.ReflectionContext.</value>
-  </data>
   <data name="Argument_ReflectionContextReturnsReflectionOnlyType" xml:space="preserve">
     <value>'{0}' returns a mapped type that is a reflection-only type which is not supported.</value>
   </data>
@@ -369,15 +354,9 @@
   <data name="ContractMismatch_MetadataViewImplementationCanNotBeNull" xml:space="preserve">
     <value>The implementation type for the MetadataView '{0} can not be null.</value>
   </data>
-  <data name="InvalidPartCreationPolicyOnImport" xml:space="preserve">
-    <value>A CreationPolicy of '(0)' can not be applied to an Import that is not an ExportFactory.</value>
-  </data>
   <data name="ExportFactory_TooManyGenericParameters" xml:space="preserve">
     <value>ExportFactory subclass '{0}' can not have more than two generic parameters.</value>
   </data>
-  <data name="CatalogMutation_Invalid" xml:space="preserve">
-    <value>ScopingPolicyCatalog does not support catalog mutation.</value>
-  </data>
   <data name="NotSupportedCatalogChanges" xml:space="preserve">
     <value>This CompositionService does not support catalog changes.</value>
   </data>
diff --git a/src/libraries/System.Composition.Hosting/src/Resources/Strings.resx b/src/libraries/System.Composition.Hosting/src/Resources/Strings.resx
index 31887609b0acf0..168e714ca191ea 100644
--- a/src/libraries/System.Composition.Hosting/src/Resources/Strings.resx
+++ b/src/libraries/System.Composition.Hosting/src/Resources/Strings.resx
@@ -57,9 +57,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="CompositionOperation_SharingLockRequired" xml:space="preserve">
-    <value>Sharing lock is required</value>
-  </data>
   <data name="Dependency_ExportNotFound" xml:space="preserve">
     <value>No export was found for the contract '{0}'</value>
   </data>
@@ -73,9 +70,6 @@
   <data name="Dependency_ToStringFormat" xml:space="preserve">
     <value>'{0}' on contract '{1}' supplied by {2}</value>
   </data>
-  <data name="ExportDescriptorNull" xml:space="preserve">
-    <value>Export descriptor fulfillment function returned null.</value>
-  </data>
   <data name="ExportDescriptor_ToStringFormat" xml:space="preserve">
     <value>{0} supplied by {1}</value>
   </data>
@@ -103,9 +97,6 @@
   <data name="Component_NotCreatableOutsideSharingBoundary" xml:space="preserve">
     <value>The component (unknown) cannot be created outside the {0} sharing boundary.</value>
   </data>
-  <data name="Keyword_MetadataViewProvider" xml:space="preserve">
-    <value>Metadata View Provider</value>
-  </data>
   <data name="MetadataViewProvider_InvalidViewImplementation" xml:space="preserve">
     <value>The type '{0}' cannot be used as a metadata view. A metadata view must be a concrete class with a parameterless or dictionary constructor.</value>
   </data>
diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/Resources/Strings.resx b/src/libraries/System.Configuration.ConfigurationManager/src/Resources/Strings.resx
index 2dd95efcdbe2fe..29f880277d1335 100644
--- a/src/libraries/System.Configuration.ConfigurationManager/src/Resources/Strings.resx
+++ b/src/libraries/System.Configuration.ConfigurationManager/src/Resources/Strings.resx
@@ -93,7 +93,7 @@
   </data>
   <!--
     other exceptions
-  -->  
+  -->
   <data name="Config_add_configurationsection_already_added" xml:space="preserve">
     <value>Cannot add a ConfigurationSection that already belongs to the Configuration.</value>
   </data>
@@ -364,9 +364,6 @@
   <data name="Config_source_invalid_format" xml:space="preserve">
     <value>The configSource attribute must be a relative physical path.</value>
   </data>
-  <data name="Config_source_invalid_chars" xml:space="preserve">
-    <value>The configSource attribute must be a relative physical path, so the '/' character is not allowed.</value>
-  </data>
   <data name="Config_source_requires_file" xml:space="preserve">
     <value>The 'configSource' property may not be set in a configuration that has no associated file.</value>
   </data>
diff --git a/src/libraries/System.Data.Common/src/Resources/Strings.resx b/src/libraries/System.Data.Common/src/Resources/Strings.resx
index 671bf490bc1351..c1a4dee0c36b05 100644
--- a/src/libraries/System.Data.Common/src/Resources/Strings.resx
+++ b/src/libraries/System.Data.Common/src/Resources/Strings.resx
@@ -97,7 +97,6 @@
   <data name="Xml_MultipleTargetConverterError" xml:space="preserve"><value>An error occurred with the multiple target converter while writing an Xml Schema.  See the inner exception for details.</value></data>
   <data name="Xml_MultipleTargetConverterEmpty" xml:space="preserve"><value>An error occurred with the multiple target converter while writing an Xml Schema.  A null or empty string was returned.</value></data>
   <data name="Xml_MergeDuplicateDeclaration" xml:space="preserve"><value>Duplicated declaration '{0}'.</value></data>
-  <data name="Xml_MissingTable" xml:space="preserve"><value>Cannot load diffGram. Table '{0}' is missing in the destination dataset.</value></data>
   <data name="Xml_MissingSQL" xml:space="preserve"><value>Cannot load diffGram. The 'sql' node is missing.</value></data>
   <data name="Xml_ColumnConflict" xml:space="preserve"><value>Column name '{0}' is defined for different mapping types.</value></data>
   <data name="Xml_InvalidPrefix_SpecialCharacters" xml:space="preserve"><value>Prefix '{0}' is not valid, because it contains special characters.</value></data>
diff --git a/src/libraries/System.Data.Odbc/src/Resources/Strings.resx b/src/libraries/System.Data.Odbc/src/Resources/Strings.resx
index b6860f2dd50aa8..2c6f3249f08040 100644
--- a/src/libraries/System.Data.Odbc/src/Resources/Strings.resx
+++ b/src/libraries/System.Data.Odbc/src/Resources/Strings.resx
@@ -128,9 +128,6 @@
   <data name="ADP_CollectionIsNotParent" xml:space="preserve">
     <value>The {0} is already contained by another {1}.</value>
   </data>
-  <data name="ADP_CollectionIsParent" xml:space="preserve">
-    <value>The {0} with is already contained by this {1}.</value>
-  </data>
   <data name="ADP_CollectionNullValue" xml:space="preserve">
     <value>The {0} only accepts non-null {1} type objects.</value>
   </data>
@@ -377,9 +374,6 @@
   <data name="ADP_TransactionZombied" xml:space="preserve">
     <value>This {0} has completed; it is no longer usable.</value>
   </data>
-  <data name="ADP_DbRecordReadOnly" xml:space="preserve">
-    <value>'{0}' cannot be called when the record is read only.</value>
-  </data>
   <data name="ADP_NonSeqByteAccess" xml:space="preserve">
     <value>Invalid {2} attempt at dataIndex '{0}'.  With CommandBehavior.SequentialAccess, you may only read from dataIndex '{1}' or greater.</value>
   </data>
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/Resources/Strings.resx b/src/libraries/System.Diagnostics.DiagnosticSource/src/Resources/Strings.resx
index 0d9ad07a07e401..f57c9d3a7b8723 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/Resources/Strings.resx
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/Resources/Strings.resx
@@ -144,9 +144,6 @@
   <data name="SetFormatOnStartedActivity" xml:space="preserve">
     <value>"Can not change format for an activity that was already started"</value>
   </data>
-  <data name="SetLinkInvalid" xml:space="preserve">
-    <value>"Can not add link to activity after it has been started"</value>
-  </data>
   <data name="SetParentIdOnActivityWithParent" xml:space="preserve">
     <value>"Can not set ParentId on activity which has parent"</value>
   </data>
diff --git a/src/libraries/System.Diagnostics.EventLog/src/Resources/Strings.resx b/src/libraries/System.Diagnostics.EventLog/src/Resources/Strings.resx
index ffeb7516c3a7ea..e0aec25828364b 100644
--- a/src/libraries/System.Diagnostics.EventLog/src/Resources/Strings.resx
+++ b/src/libraries/System.Diagnostics.EventLog/src/Resources/Strings.resx
@@ -137,9 +137,6 @@
   <data name="CantRetrieveEntries" xml:space="preserve">
     <value>Cannot retrieve all entries.</value>
   </data>
-  <data name="DuplicateLogName" xml:space="preserve">
-    <value>Only the first eight characters of a custom log name are significant, and there is already another log on the system using the first eight characters of the name given. Name given: '{0}', name of existing log: '{1}'.</value>
-  </data>
   <data name="EventID" xml:space="preserve">
     <value>Invalid eventID value '{0}'. It must be in the range between '{1}' and '{2}'.</value>
   </data>
@@ -242,7 +239,4 @@
   <data name="LogAlreadyExistsAsSource" xml:space="preserve">
     <value>Log {0} has already been registered as a source on the local computer.</value>
   </data>
-  <data name="NotSupported_IONonFileDevices" xml:space="preserve"> 
-    <value>Opening Win32 devices other than file such as COM ports, printers, disk partitions and tape drives is not supported. Avoid use of "\\\\.\\" in the path.</value> 
-  </data>
 </root>
diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/src/Resources/Strings.resx b/src/libraries/System.Diagnostics.PerformanceCounter/src/Resources/Strings.resx
index 1a5909f5194cfc..829c04125b3732 100644
--- a/src/libraries/System.Diagnostics.PerformanceCounter/src/Resources/Strings.resx
+++ b/src/libraries/System.Diagnostics.PerformanceCounter/src/Resources/Strings.resx
@@ -158,9 +158,6 @@
   <data name="SharedMemoryGhosted" xml:space="preserve">
     <value>Cannot access shared memory, AppDomain has been unloaded.</value>
   </data>
-  <data name="SetSecurityDescriptionFailed" xml:space="preserve">
-    <value>Cannot initialize security descriptor initialized.</value>
-  </data>
   <data name="CantCreateFileMapping" xml:space="preserve">
     <value>Cannot create file mapping.</value>
   </data>
@@ -322,7 +319,7 @@
   </data>
   <data name="Perflib_InvalidOperation_CounterSetContainsNoCounter" xml:space="preserve">
     <value>CounterSet '{0}' does not include any counters.</value>
-  </data>  
+  </data>
   <data name="Perflib_Argument_CounterSetAlreadyRegister" xml:space="preserve">
     <value>CounterSet '{0}' already registered.</value>
   </data>
diff --git a/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx b/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx
index 31cd6a75a072af..2584ee5909a03f 100644
--- a/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx
+++ b/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx
@@ -311,9 +311,6 @@
   <data name="UseShellExecuteNotSupported" xml:space="preserve">
     <value>UseShellExecute is not supported on this platform.</value>
   </data>
-  <data name="GetProcessInfoNotSupported" xml:space="preserve">
-    <value>Retrieving information about local processes is not supported on this platform.</value>
-  </data>
   <data name="StandardInputEncodingNotAllowed" xml:space="preserve">
     <value>StandardInputEncoding is only supported when standard input is redirected.</value>
   </data>
diff --git a/src/libraries/System.DirectoryServices.AccountManagement/src/Resources/Strings.resx b/src/libraries/System.DirectoryServices.AccountManagement/src/Resources/Strings.resx
index 4510671778d18a..dbe197a32bbf49 100644
--- a/src/libraries/System.DirectoryServices.AccountManagement/src/Resources/Strings.resx
+++ b/src/libraries/System.DirectoryServices.AccountManagement/src/Resources/Strings.resx
@@ -131,12 +131,6 @@
   <data name="StoreNotSupportMethod" xml:space="preserve">
     <value>This store does not support this method.</value>
   </data>
-  <data name="PrincipalCantSetContext" xml:space="preserve">
-    <value>The PrincipalContext can only be set on an unpersisted Principal.</value>
-  </data>
-  <data name="PrincipalUnsupportedProperty" xml:space="preserve">
-    <value>Principals in this type of store do not support the property '{0}'.</value>
-  </data>
   <data name="PrincipalUnsupportPropertyForPlatform" xml:space="preserve">
     <value>Principals in this version of the store do not support the property '{0}'.</value>
   </data>
@@ -164,30 +158,12 @@
   <data name="PrincipalMustPersistFirst" xml:space="preserve">
     <value>The Principal object must be persisted before this method can be called.</value>
   </data>
-  <data name="PrincipalIdentityTypeNotAllowed" xml:space="preserve">
-    <value>This type of identity information is not supported on principals in this type of store.</value>
-  </data>
-  <data name="PrincipalIdentityTypeNotRemovable" xml:space="preserve">
-    <value>This type of identity information can not be cleared on principals in this type of store.</value>
-  </data>
-  <data name="PrincipalCantChangeSamNameOnPersistedSAM" xml:space="preserve">
-    <value>This type of store does not permit changing the SAM account name after the principal has been persisted.</value>
-  </data>
-  <data name="EmptyIdentityType" xml:space="preserve">
-    <value>The identityType parameter cannot be empty.</value>
-  </data>
   <data name="PrincipalSearcherPersistedPrincipal" xml:space="preserve">
     <value>Persisted Principal objects cannot be used as query filters.</value>
   </data>
-  <data name="PrincipalSearcherMustSetContext" xml:space="preserve">
-    <value>A PrincipalContext must first be assigned to the PrincipalSearcher before the query can be performed.</value>
-  </data>
   <data name="PrincipalSearcherMustSetFilter" xml:space="preserve">
     <value>A QueryFilter must first be assigned to the PrincipalSearcher before the query can be performed.</value>
   </data>
-  <data name="PrincipalSearcherMustSetContextForUnderlying" xml:space="preserve">
-    <value>A PrincipalContext must first be assigned to the PrincipalSearcher before the underlying searcher can be retrieved.</value>
-  </data>
   <data name="PrincipalSearcherNoUnderlying" xml:space="preserve">
     <value>There is no underlying searcher for the type of store associated with the PrincipalContext.</value>
   </data>
@@ -212,9 +188,6 @@
   <data name="TrackedCollectionEnumInvalidPos" xml:space="preserve">
     <value>The enumerator is positioned before the first element of the collection or after the last element.</value>
   </data>
-  <data name="MultipleMatchesExceptionText" xml:space="preserve">
-    <value>More than one matching identity was found.</value>
-  </data>
   <data name="MultipleMatchingPrincipals" xml:space="preserve">
     <value>Multiple principals contain a matching Identity.</value>
   </data>
@@ -242,9 +215,6 @@
   <data name="PrincipalCollectionEnumInvalidPos" xml:space="preserve">
     <value>The enumerator is positioned before the first element of the collection or after the last element.</value>
   </data>
-  <data name="PrincipalCollectionAlreadyMember" xml:space="preserve">
-    <value>The Principal object already exists in the collection.</value>
-  </data>
   <data name="AuthenticablePrincipalMustBeSubtypeOfAuthPrinc" xml:space="preserve">
     <value>The subtype parameter must be either AuthenticablePrincipal or a subtype of AuthenticablePrincipal.</value>
   </data>
@@ -254,12 +224,6 @@
   <data name="UserMustSetContextForMethod" xml:space="preserve">
     <value>A PrincipalContext must first be assigned to the unpersisted User object before this method can be called.</value>
   </data>
-  <data name="UserDomainNotSupportedOnPlatform" xml:space="preserve">
-    <value>Domain users are not supported on this platform.</value>
-  </data>
-  <data name="UserLocalNotSupportedOnPlatform" xml:space="preserve">
-    <value>Local machine users not supported on this platform.</value>
-  </data>
   <data name="UserCouldNotFindCurrent" xml:space="preserve">
     <value>The User object for the current user could not be found.  You may not have access to it.</value>
   </data>
@@ -305,21 +269,12 @@
   <data name="StoreCtxNT4IdentityClaimWrongForm" xml:space="preserve">
     <value>The samAccountName IdentityType must be in the form "domainname\\userName", "machinename\\userName", or "userName".</value>
   </data>
-  <data name="StoreCtxCantSetTimeLimitOnIdentityClaim" xml:space="preserve">
-    <value>This store does not support setting IdentityClaims with a restricted range of times for which the IdentityClaim is valid.</value>
-  </data>
   <data name="StoreCtxGroupHasUnpersistedInsertedPrincipal" xml:space="preserve">
     <value>The Group object can not be saved until the unpersisted Principal object in its Members property is either saved or removed from the collection.</value>
   </data>
   <data name="StoreCtxNeedValueSecurityIdentityClaimToQuery" xml:space="preserve">
     <value>The Principal object must have a valid SID IdentityType in order to perform this operation.</value>
   </data>
-  <data name="StoreCtxExceptionUpdatingGroup" xml:space="preserve">
-    <value>An exception occurred while updating the group membership on the store.</value>
-  </data>
-  <data name="StoreCtxExceptionCommittingChanges" xml:space="preserve">
-    <value>An exception occurred while saving the changes to the store.</value>
-  </data>
   <data name="ADStoreCtxUnsupportedPrincipalContextForGroupInsert" xml:space="preserve">
     <value>Only domain Principal objects can be inserted into groups in this store.</value>
   </data>
@@ -371,9 +326,6 @@
   <data name="SAMStoreCtxNoComputerPasswordExpire" xml:space="preserve">
     <value>Computer accounts in this store can not have their passwords expired.</value>
   </data>
-  <data name="SAMStoreCtxIdentityClaimsImmutable" xml:space="preserve">
-    <value>This store does not permit changing the IdentityClaims on a principal once the principal has been persisted.</value>
-  </data>
   <data name="SAMStoreCtxCouldntGetSIDForGroupMember" xml:space="preserve">
     <value>One of the Principal objects to be inserted into or removed from the group's membership does not contain a SID.</value>
   </data>
@@ -407,33 +359,6 @@
   <data name="AuthZCantFindGroup" xml:space="preserve">
     <value>An error occurred while enumerating the groups.  The group could not be found.</value>
   </data>
-  <data name="ConfigHandlerConfigSectionsUnique" xml:space="preserve">
-    <value>The '{0}' element can only appear once in the configuration file.</value>
-  </data>
-  <data name="ConfigHandlerInvalidBoolAttribute" xml:space="preserve">
-    <value>The '{0}' attribute for element '{1}' of the configuration file must be set to 'true' or 'false'.</value>
-  </data>
-  <data name="ConfigHandlerInvalidEnumAttribute" xml:space="preserve">
-    <value>The '{0}' attribute for element '{1}' of the configuration file is set to an unknown value.</value>
-  </data>
-  <data name="ConfigHandlerInvalidStringAttribute" xml:space="preserve">
-    <value>The '{0}' attribute for element '{1}' of the configuration file must be set to a string.</value>
-  </data>
-  <data name="ConfigHandlerUnknownConfigSection" xml:space="preserve">
-    <value>Unknown element '{0}' was found in the configuration file.</value>
-  </data>
-  <data name="PrincipalPermWrongType" xml:space="preserve">
-    <value>The target parameter is not a PrincipalPermission.</value>
-  </data>
-  <data name="PrincipalPermXmlNotPermission" xml:space="preserve">
-    <value>The SecurityElement is not a permission.</value>
-  </data>
-  <data name="PrincipalPermXmlBadVersion" xml:space="preserve">
-    <value>The SecurityElement does not have a valid version.  Version '1' was expected.</value>
-  </data>
-  <data name="PrincipalPermXmlBadContents" xml:space="preserve">
-    <value>The SecurityElement does not contain a valid value for the 'Unrestricted' attribute.</value>
-  </data>
   <data name="ContextOptionsNotValidForMachineStore" xml:space="preserve">
     <value>The options value is invalid.  The Machine store only supports Negotiate.</value>
   </data>
@@ -452,9 +377,6 @@
   <data name="InvalidPropertyForStore" xml:space="preserve">
     <value>Property is not valid for this store type.</value>
   </data>
-  <data name="InvalidOperationForStore" xml:space="preserve">
-    <value>{0} is not supported by the {1} ContextType.</value>
-  </data>
   <data name="NameMustBeSetToPersistPrincipal" xml:space="preserve">
     <value>SamAccountName or Name must be assigned to a newly-created Principal object in this store prior to saving.</value>
   </data>
diff --git a/src/libraries/System.DirectoryServices.Protocols/src/Resources/Strings.resx b/src/libraries/System.DirectoryServices.Protocols/src/Resources/Strings.resx
index b469e621c1be10..b63f103619fbdb 100644
--- a/src/libraries/System.DirectoryServices.Protocols/src/Resources/Strings.resx
+++ b/src/libraries/System.DirectoryServices.Protocols/src/Resources/Strings.resx
@@ -117,9 +117,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="DsmlNonHttpUri" xml:space="preserve">
-    <value>The URI that is supplied must be either "http" or "https".</value>
-  </data>
   <data name="NoNegativeTimeLimit" xml:space="preserve">
     <value>A negative value is not permitted for the time limit.</value>
   </data>
@@ -129,18 +126,12 @@
   <data name="InvalidDocument" xml:space="preserve">
     <value>The DSML document could not be parsed.</value>
   </data>
-  <data name="MissingSessionId" xml:space="preserve">
-    <value>The server failed to return a session identifier.</value>
-  </data>
   <data name="MissingResponse" xml:space="preserve">
     <value>The server failed to return a DirectoryResponse.</value>
   </data>
   <data name="ErrorResponse" xml:space="preserve">
     <value>An ErrorResponse DSML element was returned.</value>
   </data>
-  <data name="BadControl" xml:space="preserve">
-    <value>The server returned an invalid DSML control.</value>
-  </data>
   <data name="NullDirectoryAttribute" xml:space="preserve">
     <value>A null reference cannot be added to DirectoryAttribute or DirectoryAttributeModification objects. </value>
   </data>
@@ -162,54 +153,9 @@
   <data name="DefaultOperationsError" xml:space="preserve">
     <value>An unspecified operation error occurred.</value>
   </data>
-  <data name="BadSearchLDAPFilter" xml:space="preserve">
-    <value>The LDAP filter string is invalid.</value>
-  </data>
   <data name="ReadOnlyProperty" xml:space="preserve">
     <value>The property is read-only.</value>
   </data>
-  <data name="MissingOperationResponseResultCode" xml:space="preserve">
-    <value>The operation response is missing the result code.</value>
-  </data>
-  <data name="MissingSearchResultEntryDN" xml:space="preserve">
-    <value>The distinguished name is missing in the SearchResultEntry of the search response.</value>
-  </data>
-  <data name="MissingSearchResultEntryAttributeName" xml:space="preserve">
-    <value>The search result is missing the attribute name.</value>
-  </data>
-  <data name="BadOperationResponseResultCode" xml:space="preserve">
-    <value>The server returned an unknown result code "{0}".</value>
-  </data>
-  <data name="MissingErrorResponseType" xml:space="preserve">
-    <value>The error response is missing the type attribute.</value>
-  </data>
-  <data name="ErrorResponseInvalidValue" xml:space="preserve">
-    <value>The error response contains an invalid type attribute "{0}".</value>
-  </data>
-  <data name="NotSupportOnDsmlErrRes" xml:space="preserve">
-    <value>This property is not supported on a DsmlErrorResponse.</value>
-  </data>
-  <data name="BadBase64Value" xml:space="preserve">
-    <value>The value is invalid base-64-encoded data.</value>
-  </data>
-  <data name="WrongAuthType" xml:space="preserve">
-    <value>The DsmlSoapHttpConnection does not support "{0}" authentication type.</value>
-  </data>
-  <data name="SessionInUse" xml:space="preserve">
-    <value>An active session already exists for this connection.</value>
-  </data>
-  <data name="ReadOnlyDocument" xml:space="preserve">
-    <value>The document is read-only.</value>
-  </data>
-  <data name="NotWellFormedResponse" xml:space="preserve">
-    <value>The response from the server is not a well-formed DSML document.</value>
-  </data>
-  <data name="NoCurrentSession" xml:space="preserve">
-    <value>No active session exists for this connection.</value>
-  </data>
-  <data name="UnknownResponseElement" xml:space="preserve">
-    <value>The server returned an unknown response element.</value>
-  </data>
   <data name="InvalidClientCertificates" xml:space="preserve">
     <value>ClientCertificates can contain only zero or one certificate.</value>
   </data>
@@ -312,9 +258,6 @@
   <data name="LDAP_SUCCESS" xml:space="preserve">
     <value>The call completed successfully.</value>
   </data>
-  <data name="NoSessionIDReturned" xml:space="preserve">
-    <value>The server failed to return a session identifier.</value>
-  </data>
   <data name="LDAP_OPERATIONS_ERROR" xml:space="preserve">
     <value>An operation error occurred.</value>
   </data>
@@ -447,9 +390,6 @@
   <data name="ValidValueType" xml:space="preserve">
     <value>The value must be a string, byte[], or Uri type.</value>
   </data>
-  <data name="TLSNotSupported" xml:space="preserve">
-    <value>Transport layer security is not supported on Windows 2000.</value>
-  </data>
   <data name="InvalidValueType" xml:space="preserve">
     <value>The specified parameter should be a "{0}" type.</value>
   </data>
@@ -459,9 +399,6 @@
   <data name="ContainNullControl" xml:space="preserve">
     <value>The collection cannot contain a null DirectoryControl object.</value>
   </data>
-  <data name="InvalidFilterType" xml:space="preserve">
-    <value>The filter type "{0}" is invalid.</value>
-  </data>
   <data name="NotReturnedAsyncResult" xml:space="preserve">
     <value>The value "{0}" is not the return value from BeginSendRequest.</value>
   </data>
@@ -474,12 +411,6 @@
   <data name="NullValueArray" xml:space="preserve">
     <value>The array should not contain null reference.</value>
   </data>
-  <data name="NonCLSException" xml:space="preserve">
-    <value>A non-CLSCompliant exception is thrown.</value>
-  </data>
-  <data name="ConcurrentBindNotSupport" xml:space="preserve">
-    <value>Fast concurrent bind is only supported on Windows 2003 and later operating systems.</value>
-  </data>
   <data name="TimespanExceedMax" xml:space="preserve">
     <value>The value exceeds the maximum allowed.</value>
   </data>
diff --git a/src/libraries/System.DirectoryServices/src/Resources/Strings.resx b/src/libraries/System.DirectoryServices/src/Resources/Strings.resx
index 64f8ba2d1f0467..437bbe46dcf95b 100644
--- a/src/libraries/System.DirectoryServices/src/Resources/Strings.resx
+++ b/src/libraries/System.DirectoryServices/src/Resources/Strings.resx
@@ -221,9 +221,6 @@
     <data name="DSPropertyValueSupportOneOperation" xml:space="preserve">
         <value>Only one type of operation can be performed in a sequence.</value>
     </data>
-    <data name="ConfigSectionsUnique" xml:space="preserve">
-        <value>The '{0}' section can only appear once in a configuration file.</value>
-    </data>
     <data name="DSUnknownFailure" xml:space="preserve">
         <value>An unknown error occurred.</value>
     </data>
@@ -314,9 +311,6 @@
     <data name="EmptyStringParameter" xml:space="preserve">
         <value>The specified string parameter is empty.</value>
     </data>
-    <data name="SupportedPlatforms" xml:space="preserve">
-        <value>The System.DirectoryServices.ActiveDirectory namespace is only supported on computers running Windows 2000 and later operating systems.</value>
-    </data>
     <data name="TargetShouldBeADAMServer" xml:space="preserve">
         <value>The name specified in the directory context must be an ADAM instance.</value>
     </data>
@@ -467,9 +461,6 @@
     <data name="ComputerNotJoinedToDomain" xml:space="preserve">
         <value>The local computer is not joined to a domain or the domain cannot be contacted.</value>
     </data>
-    <data name="VersionFailure" xml:space="preserve">
-        <value>Failed to get the version of the operating system, error is "{0}".</value>
-    </data>
     <data name="NoHostName" xml:space="preserve">
         <value>Unable to obtain DNS hostname of Active Directory domain controller with ntdsa object name "{0}".</value>
     </data>
diff --git a/src/libraries/System.Drawing.Common/src/Resources/Strings.resx b/src/libraries/System.Drawing.Common/src/Resources/Strings.resx
index 2d3d8134aabce0..eb89ee9ebb7a58 100644
--- a/src/libraries/System.Drawing.Common/src/Resources/Strings.resx
+++ b/src/libraries/System.Drawing.Common/src/Resources/Strings.resx
@@ -128,9 +128,6 @@
   <data name="ColorNotSystemColor" xml:space="preserve">
     <value>The color {0} is not a system color.</value>
   </data>
-  <data name="DotNET_ComponentType" xml:space="preserve">
-    <value>.NET Component</value>
-  </data>
   <data name="GdiplusAborted" xml:space="preserve">
     <value>Function was ended.</value>
   </data>
@@ -224,18 +221,6 @@
   <data name="IconInvalidMaskLength" xml:space="preserve">
     <value>'{0}' data length expected {1}, read {2}</value>
   </data>
-  <data name="ToolboxItemLocked" xml:space="preserve">
-    <value>Toolbox item cannot be modified.</value>
-  </data>
-  <data name="ToolboxItemInvalidPropertyType" xml:space="preserve">
-    <value>Property {0} requires an argument of type {1}.</value>
-  </data>
-  <data name="ToolboxItemValueNotSerializable" xml:space="preserve">
-    <value>Data type {0} is not serializable. Items added to a property dictionary must be serializable.</value>
-  </data>
-  <data name="ToolboxItemInvalidKey" xml:space="preserve">
-    <value>Argument should be a non-empty string.</value>
-  </data>
   <data name="IllegalState" xml:space="preserve">
     <value>Internal state of the {0} class is invalid.</value>
   </data>
@@ -263,15 +248,12 @@
   <data name="InvalidArgumentValue" xml:space="preserve">
     <value>Value of '{1}' is not valid for '{0}'.</value>
   </data>
-    <data name="InvalidArgumentValueFontConverter" xml:space="preserve">
+  <data name="InvalidArgumentValueFontConverter" xml:space="preserve">
     <value>Value of '{0}' is not valid for font size unit.</value>
   </data>
   <data name="InvalidBoundArgument" xml:space="preserve">
     <value>Value of '{1}' is not valid for '{0}'. '{0}' should be greater than {2} and less than or equal to {3}.</value>
   </data>
-  <data name="InvalidClassName" xml:space="preserve">
-    <value>Class name is not valid.</value>
-  </data>
   <data name="InvalidColor" xml:space="preserve">
     <value>Color '{0}' is not valid.</value>
   </data>
@@ -290,9 +272,6 @@
   <data name="InvalidLowBoundArgumentEx" xml:space="preserve">
     <value>Value of '{1}' is not valid for '{0}'. '{0}' must be greater than or equal to {2}.</value>
   </data>
-  <data name="InvalidPermissionLevel" xml:space="preserve">
-    <value>Permission level is not valid.</value>
-  </data>
   <data name="InvalidPermissionState" xml:space="preserve">
     <value>Permission state is not valid.</value>
   </data>
@@ -350,21 +329,12 @@
   <data name="PDOCqueryPageSettingsDescr" xml:space="preserve">
     <value>Occurs before each page is printed.  Useful for changing PageSettings for a particular page.</value>
   </data>
-  <data name="PlatformNotSupported_Drawing" xml:space="preserve">
-    <value>System.Drawing is not supported on this platform.</value>
-  </data>
   <data name="PlatformNotSupported_Unix" xml:space="preserve">
     <value>System.Drawing.Common is not supported on non-Windows platforms. See https://aka.ms/systemdrawingnonwindows for more information.</value>
   </data>
   <data name="PrintDocumentDesc" xml:space="preserve">
     <value>Defines an object that sends output to a printer.</value>
   </data>
-  <data name="PrintingPermissionBadXml" xml:space="preserve">
-    <value>XML is not valid.</value>
-  </data>
-  <data name="PrintingPermissionAttributeInvalidPermissionLevel" xml:space="preserve">
-    <value>Permission level must be between PrintingPermissionLevel.NoPrinting and PrintingPermissionLevel.AllPrinting.</value>
-  </data>
   <data name="PropertyValueInvalidEntry" xml:space="preserve">
     <value>IDictionary parameter contains at least one entry that is not valid. Ensure all values are consistent with the object's properties.</value>
   </data>
@@ -374,9 +344,6 @@
   <data name="ResourceNotFound" xml:space="preserve">
     <value>Resource '{1}' cannot be found in class '{0}'.</value>
   </data>
-  <data name="TargetNotPrintingPermission" xml:space="preserve">
-    <value>Target does not have permission to print.</value>
-  </data>
   <data name="TextParseFailedFormat" xml:space="preserve">
     <value>Text "{0}" cannot be parsed. The expected text format is "{1}".</value>
   </data>
@@ -407,12 +374,6 @@
   <data name="BlendObjectLastElementInvalid" xml:space="preserve">
     <value>Invalid Blend object. The positions array must have 1.0 as its last element.</value>
   </data>
-  <data name="DllNotFoundExceptionMessage" xml:space="preserve">
-    <value>Unable to load DLL '{0}': The specified module could not be found.</value>
-  </data>
-  <data name="EntryPointNotFoundExceptionMessage" xml:space="preserve">
-    <value>Unable to find an entry point named '{0}' in DLL '{1}'.</value>
-  </data>
   <data name="AvailableOnlyOnWMF" xml:space="preserve">
     <value>{0} only available on WMF files.</value>
   </data>
diff --git a/src/libraries/System.IO.Compression.Brotli/src/Resources/Strings.resx b/src/libraries/System.IO.Compression.Brotli/src/Resources/Strings.resx
index 8c18769cabcdcb..355df1fd20412a 100644
--- a/src/libraries/System.IO.Compression.Brotli/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Compression.Brotli/src/Resources/Strings.resx
@@ -132,9 +132,6 @@
   <data name="ArgumentOutOfRange_NeedPosNum" xml:space="preserve">
     <value>Positive number required.</value>
   </data>
-  <data name="InvalidArgumentOffsetCount" xml:space="preserve">
-    <value>Offset plus count is larger than the length of target array.</value>
-  </data>
   <data name="InvalidBeginCall" xml:space="preserve">
     <value>Only one asynchronous reader or writer is allowed time at one time.</value>
   </data>
diff --git a/src/libraries/System.IO.Compression/src/Resources/Strings.resx b/src/libraries/System.IO.Compression/src/Resources/Strings.resx
index cac801aa8fcc47..08e13fd1bb1445 100644
--- a/src/libraries/System.IO.Compression/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Compression/src/Resources/Strings.resx
@@ -131,9 +131,6 @@
   <data name="GenericInvalidData" xml:space="preserve">
     <value>Found invalid data while decoding.</value>
   </data>
-  <data name="InvalidArgumentOffsetCount" xml:space="preserve">
-    <value>Offset plus count is larger than the length of target array.</value>
-  </data>
   <data name="InvalidBeginCall" xml:space="preserve">
     <value>Only one asynchronous reader or writer is allowed time at one time.</value>
   </data>
@@ -179,9 +176,6 @@
   <data name="ZLibErrorUnexpected" xml:space="preserve">
     <value>The underlying compression routine returned an unexpected error code.</value>
   </data>
-  <data name="ArgumentNeedNonNegative" xml:space="preserve">
-    <value>The argument must be non-negative.</value>
-  </data>
   <data name="CannotBeEmpty" xml:space="preserve">
     <value>String cannot be empty.</value>
   </data>
@@ -266,9 +260,6 @@
   <data name="NumEntriesWrong" xml:space="preserve">
     <value>Number of entries expected in End Of Central Directory does not correspond to number of entries in Central Directory.</value>
   </data>
-  <data name="OffsetLengthInvalid" xml:space="preserve">
-    <value>The offset and length parameters are not valid for the array that was given.</value>
-  </data>
   <data name="ReadingNotSupported" xml:space="preserve">
     <value>This stream from ZipArchiveEntry does not support reading.</value>
   </data>
diff --git a/src/libraries/System.IO.Pipes/src/Resources/Strings.resx b/src/libraries/System.IO.Pipes/src/Resources/Strings.resx
index dfde86140b6dfe..3300dc0181fb0b 100644
--- a/src/libraries/System.IO.Pipes/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Pipes/src/Resources/Strings.resx
@@ -177,9 +177,6 @@
   <data name="InvalidOperation_PipeHandleNotSet" xml:space="preserve">
     <value>Pipe handle has not been set.  Did your PipeStream implementation call InitializeHandle?</value>
   </data>
-  <data name="InvalidOperation_PipeNotAsync" xml:space="preserve">
-    <value>Pipe is not opened in asynchronous mode.</value>
-  </data>
   <data name="InvalidOperation_PipeReadModeNotMessage" xml:space="preserve">
     <value>ReadMode is not of PipeTransmissionMode.Message.</value>
   </data>
diff --git a/src/libraries/System.IO.Ports/src/Resources/Strings.resx b/src/libraries/System.IO.Ports/src/Resources/Strings.resx
index 9ead182ebd4231..d7a4303c7efed1 100644
--- a/src/libraries/System.IO.Ports/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Ports/src/Resources/Strings.resx
@@ -200,24 +200,6 @@
   <data name="InvalidOperation_EndWriteCalledMultiple" xml:space="preserve">
     <value>EndWrite can only be called once for each asynchronous operation.</value>
   </data>
-  <data name="IO_PortNotFound" xml:space="preserve">
-    <value>The specified port does not exist.</value>
-  </data>
-  <data name="IO_PortNotFoundFileName" xml:space="preserve">
-    <value>The port '{0}' does not exist.</value>
-  </data>
-  <data name="UnauthorizedAccess_IODenied_NoPortName" xml:space="preserve">
-    <value>Access to the port is denied.</value>
-  </data>
-  <data name="IO_PathTooLong_PortName" xml:space="preserve">
-    <value>The specified port name is too long.  The port name must be less than 260 characters.</value>
-  </data>
-  <data name="IO_SharingViolation_NoPortName" xml:space="preserve">
-    <value>The process cannot access the port because it is being used by another process.</value>
-  </data>
-  <data name="IO_SharingViolation_Port" xml:space="preserve">
-    <value>The process cannot access the port '{0}' because it is being used by another process.</value>
-  </data>
   <data name="UnauthorizedAccess_IODenied_Port" xml:space="preserve">
     <value>Access to the port '{0}' is denied.</value>
   </data>
@@ -227,9 +209,6 @@
   <data name="PlatformNotSupported_SerialPort_GetPortNames" xml:space="preserve">
     <value>Enumeration of serial port names is not supported on the current platform.</value>
   </data>
-  <data name="IO_PathTooLong_Path_PortName" xml:space="preserve">
-    <value>The specified port name '{0}' is too long.  The port name must be less than 260 characters.</value>
-  </data>
   <!-- used by shared file IOErrors.cs -->
   <data name="IO_PathTooLong" xml:space="preserve">
     <value>The specified file name or path is too long, or a component of the specified path is too long.</value>
diff --git a/src/libraries/System.Memory/src/Resources/Strings.resx b/src/libraries/System.Memory/src/Resources/Strings.resx
index 3734871f888dac..6a69c1128e1525 100644
--- a/src/libraries/System.Memory/src/Resources/Strings.resx
+++ b/src/libraries/System.Memory/src/Resources/Strings.resx
@@ -141,9 +141,6 @@
   <data name="EndPositionNotReached" xml:space="preserve">
     <value>End position was not reached during enumeration.</value>
   </data>
-  <data name="UnexpectedSegmentType" xml:space="preserve">
-    <value>Unexpected segment type.</value>
-  </data>
   <data name="BufferWriterAdvancedTooFar" xml:space="preserve">
     <value>Cannot advance past the end of the buffer, which has a size of {0}.</value>
   </data>
diff --git a/src/libraries/System.Net.Http/src/Resources/Strings.resx b/src/libraries/System.Net.Http/src/Resources/Strings.resx
index 7464b6aa14086a..9e9afe1491426f 100644
--- a/src/libraries/System.Net.Http/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Http/src/Resources/Strings.resx
@@ -123,9 +123,6 @@
   <data name="net_http_httpmethod_format_error" xml:space="preserve">
     <value>The format of the HTTP method is invalid.</value>
   </data>
-  <data name="net_http_httpmethod_notsupported_error" xml:space="preserve">
-    <value>The HTTP method '{0}' is not supported on this platform.</value>
-  </data>
   <data name="net_http_reasonphrase_format_error" xml:space="preserve">
     <value>The reason phrase must not contain new-line characters.</value>
   </data>
@@ -231,9 +228,6 @@
   <data name="net_http_content_buffersize_limit" xml:space="preserve">
     <value>Buffering more than {0} bytes is not supported.</value>
   </data>
-  <data name="net_http_value_not_supported" xml:space="preserve">
-    <value>The value '{0}' is not supported for property '{1}'.</value>
-  </data>
   <data name="net_http_io_read" xml:space="preserve">
     <value>The read operation failed, see inner exception.</value>
   </data>
@@ -297,9 +291,6 @@
   <data name="UnauthorizedAccess_IODenied_Path" xml:space="preserve">
     <value>Access to the path '{0}' is denied.</value>
   </data>
-  <data name="net_http_content_no_concurrent_reads" xml:space="preserve">
-    <value>The stream does not support concurrent read operations.</value>
-  </data>
   <data name="net_http_username_empty_string" xml:space="preserve">
     <value>The username for a credential object cannot be null or empty.</value>
   </data>
@@ -357,9 +348,6 @@
   <data name="net_http_invalid_response_pseudo_header_in_trailer" xml:space="preserve">
     <value>Received an HTTP/2 pseudo-header as a trailing header.</value>
   </data>
-  <data name="net_http_unix_handler_disposed" xml:space="preserve">
-    <value>The handler was disposed of while active operations were in progress.</value>
-  </data>
   <data name="net_http_buffer_insufficient_length" xml:space="preserve">
     <value>The buffer was not long enough.</value>
   </data>
@@ -381,12 +369,6 @@
   <data name="ObjectDisposed_StreamClosed" xml:space="preserve">
     <value>Cannot access a closed stream.</value>
   </data>
-  <data name="net_http_feature_requires_Windows10Version1607" xml:space="preserve">
-    <value>Using this feature requires Windows 10 Version 1607.</value>
-  </data>
-  <data name="net_http_feature_UWPClientCertSupportRequiresCertInPersonalCertificateStore" xml:space="preserve">
-    <value>Client certificate was not found in the personal (\"MY\") certificate store. In UWP, client certificates are only supported if they have been added to that certificate store.</value>
-  </data>
   <data name="net_http_invalid_proxy_scheme" xml:space="preserve">
     <value>Only the 'http', 'socks4', 'socks4a' and 'socks5' schemes are allowed for proxies.</value>
   </data>
@@ -516,9 +498,6 @@
   <data name="net_http_hpack_unexpected_end" xml:space="preserve">
     <value>End of headers reached with incomplete token.</value>
   </data>
-  <data name="net_http_hpack_encode_failure" xml:space="preserve">
-    <value>Failed to HPACK encode the headers.</value>
-  </data>
   <data name="net_http_headers_exceeded_length" xml:space="preserve">
     <value>The HTTP headers length exceeded the set limit of {0} bytes.</value>
   </data>
@@ -528,9 +507,6 @@
   <data name="net_http_http3_connection_error" xml:space="preserve">
     <value>The HTTP/3 server sent invalid data on the connection. HTTP/3 error code '{0}' (0x{1}).</value>
   </data>
-  <data name="net_http_http3_stream_error" xml:space="preserve">
-    <value>The HTTP/3 server sent invalid data on the stream. HTTP/3 error code '{0}' (0x{1}).</value>
-  </data>
   <data name="net_http_retry_on_older_version" xml:space="preserve">
     <value>The server is unable to process the request using the current HTTP version and indicates the request should be retried on an older HTTP version.</value>
   </data>
@@ -549,9 +525,6 @@
   <data name="net_quic_connectionaborted" xml:space="preserve">
     <value>Connection aborted by peer ({0}).</value>
   </data>
-  <data name="net_quic_notsupported" xml:space="preserve">
-    <value>QUIC is not supported on this platform. See https://aka.ms/dotnetquic</value>
-  </data>
   <data name="net_quic_operationaborted" xml:space="preserve">
     <value>Operation aborted.</value>
   </data>
@@ -570,9 +543,6 @@
   <data name="net_http_requested_version_cannot_establish" xml:space="preserve">
     <value>Requesting HTTP version {0} with version policy {1} while unable to establish HTTP/{2} connection.</value>
   </data>
-  <data name="net_http_requested_version_alpn_refused" xml:space="preserve">
-    <value>Requesting HTTP version {0} with version policy {1} while server returned HTTP/1.1 in ALPN.</value>
-  </data>
   <data name="net_http_requested_version_server_refused" xml:space="preserve">
     <value>Requesting HTTP version {0} with version policy {1} while server offers only version fallback.</value>
   </data>
diff --git a/src/libraries/System.Net.Ping/src/Resources/Strings.resx b/src/libraries/System.Net.Ping/src/Resources/Strings.resx
index 1ad9023082ef59..1a1c7112b5d30d 100644
--- a/src/libraries/System.Net.Ping/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Ping/src/Resources/Strings.resx
@@ -84,9 +84,6 @@
   <data name="net_ipv6_not_installed" xml:space="preserve">
     <value>IPv6 is not installed.</value>
   </data>
-  <data name="net_ping_not_supported_uwp" xml:space="preserve">
-    <value>Ping functionality is not currently supported in UWP.</value>
-  </data>
   <data name="SystemNetPing_PlatformNotSupported" xml:space="preserve">
     <value>System.Net.Ping is not supported on this platform.</value>
   </data>
diff --git a/src/libraries/System.Net.Quic/src/Resources/Strings.resx b/src/libraries/System.Net.Quic/src/Resources/Strings.resx
index a692407e183640..f1e227448e030a 100644
--- a/src/libraries/System.Net.Quic/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Quic/src/Resources/Strings.resx
@@ -123,12 +123,6 @@
   <data name="net_quic_connectionaborted" xml:space="preserve">
     <value>Connection aborted by peer ({0}).</value>
   </data>
-  <data name="net_quic_noloopback" xml:space="preserve">
-    <value>Must pass loopback address and port 0</value>
-  </data>
-  <data name="net_quic_notsupported" xml:space="preserve">
-    <value>QUIC is not supported on this platform. See https://aka.ms/dotnetquic</value>
-  </data>
   <data name="net_quic_operationaborted" xml:space="preserve">
     <value>Operation aborted.</value>
   </data>
diff --git a/src/libraries/System.Net.Requests/src/Resources/Strings.resx b/src/libraries/System.Net.Requests/src/Resources/Strings.resx
index a3b2bb922d3c78..e93fad131a92c4 100644
--- a/src/libraries/System.Net.Requests/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Requests/src/Resources/Strings.resx
@@ -87,9 +87,6 @@
   <data name="net_MethodNotImplementedException" xml:space="preserve">
     <value>This method is not implemented by this class.</value>
   </data>
-  <data name="net_OperationNotSupportedException" xml:space="preserve">
-    <value>This operation is not supported.</value>
-  </data>
   <data name="net_PropertyNotImplementedException" xml:space="preserve">
     <value>This property is not implemented by this class.</value>
   </data>
diff --git a/src/libraries/System.Net.Security/src/Resources/Strings.resx b/src/libraries/System.Net.Security/src/Resources/Strings.resx
index e33b4122a7d53d..d85383c3e906bc 100644
--- a/src/libraries/System.Net.Security/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Security/src/Resources/Strings.resx
@@ -221,9 +221,6 @@
   <data name="net_auth_alert" xml:space="preserve">
     <value>Authentication failed on the remote side (the stream might still be available for additional authentication attempts).</value>
   </data>
-  <data name="net_auth_ignored_reauth" xml:space="preserve">
-    <value>Re-authentication failed because the remote party continued to encrypt more than {0} bytes before answering re-authentication.</value>
-  </data>
   <data name="net_auth_message_not_encrypted" xml:space="preserve">
     <value>Protocol error: A received message contains a valid signature but it was not encrypted as required by the effective Protection Level.</value>
   </data>
@@ -233,9 +230,6 @@
   <data name="net_frame_size" xml:space="preserve">
     <value>Received an invalid authentication frame. The message size is limited to {0} bytes, attempted to read {1} bytes.</value>
   </data>
-  <data name="net_frame_read_io" xml:space="preserve">
-    <value>Received incomplete authentication message. Remote party has probably closed the connection.</value>
-  </data>
   <data name="net_frame_read_size" xml:space="preserve">
     <value>Cannot determine the frame size or a corrupted frame was received.</value>
   </data>
@@ -245,78 +239,9 @@
   <data name="net_invalid_enum" xml:space="preserve">
     <value>The specified value is not valid in the '{0}' enumeration.</value>
   </data>
-  <data name="event_EnumerateSecurityPackages" xml:space="preserve">
-    <value>Enumerating security packages:</value>
-  </data>
-  <data name="event_SspiPackageNotFound" xml:space="preserve">
-    <value>Security package '{0}' was not found.</value>
-  </data>
-  <data name="event_SecurityContextInputBuffer" xml:space="preserve">
-    <value>{0}(In-Buffer length={1}, Out-Buffer length={2}, returned code={3}).</value>
-  </data>
-  <data name="event_SecurityContextInputBuffers" xml:space="preserve">
-    <value>{0}(In-Buffers count={1}, Out-Buffer length={2}, returned code={3}).</value>
-  </data>
-  <data name="event_SspiSelectedCipherSuite" xml:space="preserve">
-    <value>{0}(Protocol={1}, Cipher={2} {3} bit strength, Hash={4} {5} bit strength, Key Exchange={6} {7} bit strength).</value>
-  </data>
-  <data name="event_RemoteCertificate" xml:space="preserve">
-    <value>Remote certificate: {0}.</value>
-  </data>
-  <data name="event_LocatingPrivateKey" xml:space="preserve">
-    <value>Locating the private key for the certificate: {0}.</value>
-  </data>
-  <data name="event_CertIsType2" xml:space="preserve">
-    <value>Certificate is of type X509Certificate2 and contains the private key.</value>
-  </data>
-  <data name="event_FoundCertInStore" xml:space="preserve">
-    <value>Found the certificate in the {0} store.</value>
-  </data>
-  <data name="event_NotFoundCertInStore" xml:space="preserve">
-    <value>Cannot find the certificate in either the LocalMachine store or the CurrentUser store.</value>
-  </data>
   <data name="net_log_open_store_failed" xml:space="preserve">
     <value>Opening Certificate store {0} failed, exception: {1}.</value>
   </data>
-  <data name="event_CertificateFromDelegate" xml:space="preserve">
-    <value>Got a certificate from the client delegate.</value>
-  </data>
-  <data name="event_NoDelegateNoClientCert" xml:space="preserve">
-    <value>Client delegate did not provide a certificate; and there are not other user-provided certificates. Need to attempt a session restart.</value>
-  </data>
-  <data name="event_NoDelegateButClientCert" xml:space="preserve">
-    <value>Client delegate did not provide a certificate; but there are other user-provided certificates.</value>
-  </data>
-  <data name="event_AttemptingRestartUsingCert" xml:space="preserve">
-    <value>Attempting to restart the session using the user-provided certificate: {0}.</value>
-  </data>
-  <data name="event_NoIssuersTryAllCerts" xml:space="preserve">
-    <value>We have user-provided certificates. The server has not specified any issuers, so try all the certificates.</value>
-  </data>
-  <data name="event_LookForMatchingCerts" xml:space="preserve">
-    <value>We have user-provided certificates. The server has specified {0} issuer(s). Looking for certificates that match any of the issuers.</value>
-  </data>
-  <data name="event_SelectedCert" xml:space="preserve">
-    <value>Selected certificate: {0}.</value>
-  </data>
-  <data name="event_CertsAfterFiltering" xml:space="preserve">
-    <value>Left with {0} client certificates to choose from.</value>
-  </data>
-  <data name="event_FindingMatchingCerts" xml:space="preserve">
-    <value>Trying to find a matching certificate in the certificate store.</value>
-  </data>
-  <data name="event_UsingCachedCredential" xml:space="preserve">
-    <value>Using the cached credential handle.</value>
-  </data>
-  <data name="event_RemoteCertDeclaredValid" xml:space="preserve">
-    <value>Remote certificate was verified as valid by the user.</value>
-  </data>
-  <data name="event_RemoteCertUserDeclaredInvalid" xml:space="preserve">
-    <value>Remote certificate was verified as invalid by the user.</value>
-  </data>
-  <data name="event_RemoteCertHasNoErrors" xml:space="preserve">
-    <value>Remote certificate has no errors.</value>
-  </data>
   <data name="net_log_remote_cert_has_errors" xml:space="preserve">
     <value>Remote certificate has errors:</value>
   </data>
@@ -374,9 +299,6 @@
   <data name="net_ssl_write_bio_failed_error" xml:space="preserve">
     <value>SSL Write BIO failed with OpenSSL error - {0}.</value>
   </data>
-  <data name="net_ssl_x509Name_push_failed_error" xml:space="preserve">
-    <value>Failed to push X509_NAME into stack.</value>
-  </data>
   <data name="net_ssl_get_connection_info_failed" xml:space="preserve">
     <value>Getting SSL connection info failed with OpenSSL error - {0}.</value>
   </data>
@@ -457,7 +379,7 @@
   </data>
   <data name="net_ssl_renegotiate_buffer" xml:space="preserve">
     <value>Client stream needs to be drained before renegotiation.</value>
-  </data>  
+  </data>
   <data name="net_android_ssl_api_level_unsupported" xml:space="preserve">
     <value>Setting an SNI hostname is not supported on this API level.</value>
   </data>
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/Resources/Strings.resx b/src/libraries/System.Net.Security/tests/FunctionalTests/Resources/Strings.resx
index c747b327c487eb..232060e5f83171 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/Resources/Strings.resx
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/Resources/Strings.resx
@@ -72,15 +72,6 @@
   <data name="net_gssapi_ntlm_missing_plugin" xml:space="preserve">
     <value>NTLM authentication requires the GSSAPI plugin 'gss-ntlmssp'.</value>
   </data>
-  <data name="net_context_establishment_failed" xml:space="preserve">
-    <value>GSSAPI security context establishment failed with status: {0} (Minor status: {1})</value>
-  </data>
-  <data name="net_context_wrap_failed" xml:space="preserve">
-    <value>GSSAPI encryption or signing failed with status: {0} (Minor status: {1})</value>
-  </data>
-  <data name="net_context_unwrap_failed" xml:space="preserve">
-    <value>GSSAPI decryption or signature verification failed with status: {0} (Minor status: {1})</value>
-  </data>
   <data name="net_context_buffer_too_small" xml:space="preserve">
     <value>Insufficient buffer space. Required: {0} Actual: {1}</value>
   </data>
diff --git a/src/libraries/System.Net.Sockets/src/Resources/Strings.resx b/src/libraries/System.Net.Sockets/src/Resources/Strings.resx
index 69eff9dbb985e6..57d1a94b6ae6bd 100644
--- a/src/libraries/System.Net.Sockets/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Sockets/src/Resources/Strings.resx
@@ -324,9 +324,6 @@
   <data name="SystemNetSockets_PlatformNotSupported" xml:space="preserve">
     <value>System.Net.Sockets is not supported on this platform.</value>
   </data>
-  <data name="net_sockets_accept_receive_apm_notsupported" xml:space="preserve">
-    <value>This platform does not support receiving data with Socket.BeginAccept/EndAccept.  Instead, make a separate call to ReceiveAsync or BeginReceive/EndReceive.</value>
-  </data>
   <data name="net_sockets_handle_already_used" xml:space="preserve">
     <value>Handle is already used by another Socket.</value>
   </data>
diff --git a/src/libraries/System.Net.WebSockets.Client/src/Resources/Strings.resx b/src/libraries/System.Net.WebSockets.Client/src/Resources/Strings.resx
index 7b4718b554a151..360d9f9a337e12 100644
--- a/src/libraries/System.Net.WebSockets.Client/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.WebSockets.Client/src/Resources/Strings.resx
@@ -123,21 +123,6 @@
   <data name="net_securityprotocolnotsupported" xml:space="preserve">
     <value>The requested security protocol is not supported.</value>
   </data>
-  <data name="net_WebSockets_UWPClientCertSupportRequiresWindows10GreaterThan1703" xml:space="preserve">
-    <value>Client certificates in UWP are unsupported in Windows 10 version 1703 and earlier versions. Please upgrade Windows 10 to a later release.</value>
-  </data>
-  <data name="net_WebSockets_UWPClientCertSupportRequiresCertInPersonalCertificateStore" xml:space="preserve">
-    <value>Client certificate was not found in the personal (\"MY\") certificate store. In UWP, client certificates are only supported if they have been added to that certificate store.</value>
-  </data>
-  <data name="net_WebSockets_RemoteValidationCallbackNotSupported" xml:space="preserve">
-    <value>ClientWebSocketOptions.RemoteCertificateValidationCallback is not supported on this platform.</value>
-  </data>
-  <data name="net_WebSockets_Connection_Aborted" xml:space="preserve">
-    <value>Connection was aborted.</value>
-  </data>
-  <data name="net_WebSockets_Invalid_Binary_Type" xml:space="preserve">
-    <value>WebSocket binary type '{0}' not supported.</value>
-  </data>
   <data name="net_WebSockets_ServerWindowBitsNegotiationFailure" xml:space="preserve">
     <value>The WebSocket failed to negotiate max server window bits. The client requested {0} but the server responded with {1}.</value>
   </data>
diff --git a/src/libraries/System.Private.DataContractSerialization/src/Resources/Strings.resx b/src/libraries/System.Private.DataContractSerialization/src/Resources/Strings.resx
index b1fd0673389336..f772c16d39646f 100644
--- a/src/libraries/System.Private.DataContractSerialization/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.DataContractSerialization/src/Resources/Strings.resx
@@ -417,9 +417,6 @@
   <data name="NoConversionPossibleTo" xml:space="preserve">
     <value>An internal error has occurred. No conversion is possible to '{0}' - error generating code for serialization.</value>
   </data>
-  <data name="NoDefaultConstructorForCollection" xml:space="preserve">
-    <value>Collection type '{0}' doesn't have default constructor.</value>
-  </data>
   <data name="NoGetMethodForProperty" xml:space="preserve">
     <value>No get method for property '{1}' in type '{0}'.</value>
   </data>
@@ -1137,9 +1134,6 @@
   <data name="PlatformNotSupported_SchemaImporter" xml:space="preserve">
     <value>The implementation of the function requires System.Runtime.Serialization.SchemaImporter which is not supported on this platform.</value>
   </data>
-  <data name="PlatformNotSupported_Canonicalization" xml:space="preserve">
-    <value>The canonicalization process is not supported on this platform.</value>
-  </data>
   <data name="FactoryTypeNotISerializable" xml:space="preserve">
     <value>Factory type '{0}' for ISerializable type '{1}' must also be ISerializable.</value>
   </data>
@@ -1155,9 +1149,6 @@
   <data name="InvalidInclusivePrefixListCollection" xml:space="preserve">
     <value>The inclusive namespace prefix collection cannot contain null as one of the items.</value>
   </data>
-  <data name="FailedToCreateMethodDelegate" xml:space="preserve">
-    <value>Failed to create Delegate for method '{0}' of type '{1}'.</value>
-  </data>
   <data name="CannotSetTwice" xml:space="preserve">
     <value>Cannot set option twice.</value>
   </data>
diff --git a/src/libraries/System.Private.Runtime.InteropServices.JavaScript/src/Resources/Strings.resx b/src/libraries/System.Private.Runtime.InteropServices.JavaScript/src/Resources/Strings.resx
index 3d23d9c39e926e..debf0296248489 100644
--- a/src/libraries/System.Private.Runtime.InteropServices.JavaScript/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.Runtime.InteropServices.JavaScript/src/Resources/Strings.resx
@@ -123,21 +123,6 @@
   <data name="ArgumentCannotBeNullWithLength" xml:space="preserve">
     <value>Invalid argument: {0} can not be null and must have a length</value>
   </data>
-  <data name="CoreObjectErrorBinding" xml:space="preserve">
-    <value>CoreObject Error binding: {0}</value>
-  </data>
-  <data name="ErrorReleasingObject" xml:space="preserve">
-    <value>Error releasing object {0}</value>
-  </data>
-  <data name="HostObjectErrorBinding" xml:space="preserve">
-    <value>HostObject Error binding: {0}</value>
-  </data>
-  <data name="JSObjectErrorBinding" xml:space="preserve">
-    <value>JSObject Error binding: {0}</value>
-  </data>
-  <data name="MultipleHandlesPointingJsId" xml:space="preserve">
-    <value>Multiple handles pointing at jsId: {0}</value>
-  </data>
   <data name="SystemRuntimeInteropServicesJavaScript_PlatformNotSupported" xml:space="preserve">
     <value>System.Private.Runtime.InteropServices.JavaScript is not supported on this platform.</value>
   </data>
@@ -150,7 +135,4 @@
   <data name="UnableCastObjectToType" xml:space="preserve">
     <value>Unable to cast object of type {0} to type {1}.</value>
   </data>
-  <data name="ValueTypeNotSupported" xml:space="preserve">
-    <value>ValueType arguments are not supported.</value>
-  </data>
 </root>
\ No newline at end of file
diff --git a/src/libraries/System.Private.Xml/src/Resources/Strings.resx b/src/libraries/System.Private.Xml/src/Resources/Strings.resx
index 112359dfecba8c..8fc3de76fe51cd 100644
--- a/src/libraries/System.Private.Xml/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.Xml/src/Resources/Strings.resx
@@ -2829,9 +2829,6 @@
   <data name="Arg_NeverValueType" xml:space="preserve">
     <value>Only TypeKind.Root can be set for typeof(object) which is never value type.</value>
   </data>
-  <data name="XmlInternalErrorReaderAdvance" xml:space="preserve">
-    <value>Internal error: deserialization failed to advance over underlying stream.</value>
-  </data>
   <data name="Enc_InvalidByteInEncoding" xml:space="preserve">
     <value>Invalid byte was found at index {0}.</value>
   </data>
@@ -2844,9 +2841,6 @@
   <data name="Arg_IncompatibleParamType" xml:space="preserve">
     <value>Type is incompatible.</value>
   </data>
-  <data name="Xml_SystemPathResolverCannotOpenUri" xml:space="preserve">
-    <value>Cannot open '{0}'. The Uri parameter must be a file system relative or absolute path.</value>
-  </data>
   <data name="Xml_EndOfInnerExceptionStack" xml:space="preserve">
     <value>--- End of inner exception stack trace ---</value>
   </data>
@@ -3126,9 +3120,6 @@
   <data name="Xslt_NonTemplateTunnel" xml:space="preserve">
     <value>Stylesheet or function parameter '{0}' cannot have attribute 'tunnel'.</value>
   </data>
-  <data name="Xslt_RequiredOnFunction" xml:space="preserve">
-    <value>The 'required' attribute must not be specified for parameter '{0}'. Function parameters are always mandatory. </value>
-  </data>
   <data name="Xslt_ExcludeDefault" xml:space="preserve">
     <value>Value '#default' is used within the 'exclude-result-prefixes' attribute and the parent element of this attribute has no default namespace.</value>
   </data>
@@ -3306,9 +3297,6 @@
   <data name="Xslt_ScriptInvalidPrefix" xml:space="preserve">
     <value>Cannot find the script or external object that implements prefix '{0}'.</value>
   </data>
-  <data name="Xslt_ScriptDub" xml:space="preserve">
-    <value>Namespace '{0}' has a duplicate implementation.</value>
-  </data>
   <data name="Xslt_ScriptEmpty" xml:space="preserve">
     <value>The 'msxsl:script' element cannot be empty.</value>
   </data>
@@ -3345,9 +3333,6 @@
   <data name="ArrayTypeIsNotSupported" xml:space="preserve">
     <value>Array of type {0} is not supported.</value>
   </data>
-  <data name="Xml_MissingSerializationCodeException" xml:space="preserve">
-    <value>Type '{0}' cannot be serialized by XmlSerializer, serialization code for the type is missing. Consult the SDK documentation for adding it as a root serialization type. https://go.microsoft.com/fwlink/?LinkId=613136</value>
-  </data>
   <data name="Xslt_UpperCaseFirstNotSupported" xml:space="preserve">
     <value>Uppercase-First sorting option is not supported.</value>
   </data>
@@ -3444,15 +3429,9 @@ Usage: dotnet {0} [--assembly &lt;assembly file path&gt;] [--type &lt;type name&
   <data name="HelpHelp" xml:space="preserve">
     <value>     {0}|{1}       Show help.</value>
   </data>
-  <data name="MoreHelp" xml:space="preserve">
-    <value>If you would like more help, please type "sgen {0}".</value>
-  </data>
   <data name="GenerateSerializerNotFound" xml:space="preserve">
     <value>Method 'System.Xml.Serialization.XmlSerializer.GenerateSerializer' was not found. This is likely because you are using an older version of the framework. Please update to .NET Core v2.1 or later.</value>
   </data>
-  <data name="event_XmlSerializerExpired" xml:space="preserve">
-    <value>Pre-generated serializer '{0}' has expired. You need to re-generate serializer for '{1}'</value>
-  </data>
   <data name="CompilingScriptsNotSupported" xml:space="preserve">
     <value>Compiling JScript/CSharp scripts is not supported</value>
   </data>
diff --git a/src/libraries/System.Reflection.Context/src/Resources/Strings.resx b/src/libraries/System.Reflection.Context/src/Resources/Strings.resx
index faa2e9cbb08c0d..3b0d6ec30a2a62 100644
--- a/src/libraries/System.Reflection.Context/src/Resources/Strings.resx
+++ b/src/libraries/System.Reflection.Context/src/Resources/Strings.resx
@@ -66,9 +66,6 @@
   <data name="Argument_PropertyTypeFromDifferentContext" xml:space="preserve">
     <value>The property type needs to be mapped to the current ReflectionContext.</value>
   </data>
-  <data name="Argument_SetMethNotFnd" xml:space="preserve">
-    <value>The set accessor of the property was not found.</value>
-  </data>
   <data name="Format_AttributeUsage" xml:space="preserve">
     <value>Duplicate AttributeUsageAttribute records found on attribute type {0}.</value>
   </data>
diff --git a/src/libraries/System.Runtime.Caching/src/Resources/Strings.resx b/src/libraries/System.Runtime.Caching/src/Resources/Strings.resx
index 92219ad3083104..2dee4b5671ea18 100644
--- a/src/libraries/System.Runtime.Caching/src/Resources/Strings.resx
+++ b/src/libraries/System.Runtime.Caching/src/Resources/Strings.resx
@@ -116,9 +116,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="Config_unable_to_get_section" xml:space="preserve">
-    <value>Unable to retrieve configuration section '{0}'.</value>
-  </data>
   <data name="TimeSpan_invalid_format" xml:space="preserve">
     <value>Invalid configuration: {0}="{1}".  The {0} value must be a time interval that can be parsed by System.TimeSpan.Parse.</value>
   </data>
diff --git a/src/libraries/System.Runtime.Serialization.Formatters/src/Resources/Strings.resx b/src/libraries/System.Runtime.Serialization.Formatters/src/Resources/Strings.resx
index db744f8c42ee82..df3d7f43119155 100644
--- a/src/libraries/System.Runtime.Serialization.Formatters/src/Resources/Strings.resx
+++ b/src/libraries/System.Runtime.Serialization.Formatters/src/Resources/Strings.resx
@@ -237,9 +237,6 @@
   <data name="Serialization_NoMemberInfo" xml:space="preserve">
     <value>No MemberInfo for Object {0}.</value>
   </data>
-  <data name="Serialization_DuplicateSelector" xml:space="preserve">
-    <value>Type {0} and the types derived from it (such as {1}) are not permitted to be deserialized at this security level.</value>
-  </data>
   <data name="Serialization_SurrogateCycleInArgument" xml:space="preserve">
     <value>Selector contained a cycle.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
index 4577d05e6187cb..bc868c30ba2dda 100644
--- a/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
@@ -93,30 +93,6 @@
   <data name="Cryptography_ArgECDHRequiresECDHKey" xml:space="preserve">
     <value>Keys used with the ECDiffieHellmanCng algorithm must have an algorithm group of ECDiffieHellman.</value>
   </data>
-  <data name="Cryptography_ArgExpectedECDiffieHellmanCngPublicKey" xml:space="preserve">
-    <value>DeriveKeyMaterial requires an ECDiffieHellmanCngPublicKey.</value>
-  </data>
-  <data name="Cryptography_Asn_EnumeratedValueRequiresNonFlagsEnum" xml:space="preserve">
-    <value>ASN.1 Enumerated values only apply to enum types without the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListRequiresFlagsEnum" xml:space="preserve">
-    <value>Named bit list operations require an enum with the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListValueTooBig" xml:space="preserve">
-    <value>The encoded named bit list value is larger than the value size of the '{0}' enum.</value>
-  </data>
-  <data name="Cryptography_Asn_UniversalValueIsFixed" xml:space="preserve">
-    <value>Tags with TagClass Universal must have the appropriate TagValue value for the data type being read or written.</value>
-  </data>
-  <data name="Cryptography_Asn_UnusedBitCountRange" xml:space="preserve">
-    <value>Unused bit count must be between 0 and 7, inclusive.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_EncodeUnbalancedStack" xml:space="preserve">
-    <value>Encode cannot be called while a Sequence or SetOf is still open.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_PopWrongTag" xml:space="preserve">
-    <value>Cannot pop the requested tag as it is not currently in progress.</value>
-  </data>
   <data name="Cryptography_TlsRequiresLabelAndSeed" xml:space="preserve">
     <value>The TLS key derivation function requires both the label and seed properties to be set.</value>
   </data>
@@ -240,9 +216,6 @@
   <data name="Cryptography_UnsupportedPaddingMode" xml:space="preserve">
     <value>The specified PaddingMode is not supported.</value>
   </data>
-  <data name="Cryptography_TransformBeyondEndOfBuffer" xml:space="preserve">
-    <value>Attempt to transform beyond end of buffer.</value>
-  </data>
   <data name="Cryptography_UnexpectedTransformTruncation" xml:space="preserve">
     <value>CNG provider unexpectedly terminated encryption or decryption prematurely.</value>
   </data>
@@ -258,9 +231,6 @@
   <data name="Cryptography_WeakKey" xml:space="preserve">
     <value>Specified key is a known weak key for this algorithm and cannot be used.</value>
   </data>
-  <data name="Cryptography_WriteEncodedValue_OneValueAtATime" xml:space="preserve">
-    <value>The input to WriteEncodedValue must represent a single encoded value with no trailing data.</value>
-  </data>
   <data name="PlatformNotSupported_CryptographyCng" xml:space="preserve">
     <value>Windows Cryptography Next Generation (CNG) is not supported on this platform.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx
index 0c2d22c90f61a2..cf77078e43c081 100644
--- a/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx
@@ -203,9 +203,6 @@
   <data name="Cryptography_RSA_DecryptWrongSize" xml:space="preserve">
     <value>The length of the data to decrypt is not valid for the size of this key.</value>
   </data>
-  <data name="Cryptography_TransformBeyondEndOfBuffer" xml:space="preserve">
-    <value>Attempt to transform beyond end of buffer.</value>
-  </data>
   <data name="Cryptography_UnknownHashAlgorithm" xml:space="preserve">
     <value>'{0}' is not a known hash algorithm.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx
index d27bec392771f2..11c10ccd63a311 100644
--- a/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx
@@ -206,30 +206,6 @@
   <data name="Cryptography_SignHash_WrongSize" xml:space="preserve">
     <value>The provided hash value is not the expected size for the specified hash algorithm.</value>
   </data>
-  <data name="Cryptography_WriteEncodedValue_OneValueAtATime" xml:space="preserve">
-    <value>The input to WriteEncodedValue must represent a single encoded value with no trailing data.</value>
-  </data>
-  <data name="Cryptography_Asn_EnumeratedValueRequiresNonFlagsEnum" xml:space="preserve">
-    <value>ASN.1 Enumerated values only apply to enum types without the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListRequiresFlagsEnum" xml:space="preserve">
-    <value>Named bit list operations require an enum with the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListValueTooBig" xml:space="preserve">
-    <value>The encoded named bit list value is larger than the value size of the '{0}' enum.</value>
-  </data>
-  <data name="Cryptography_Asn_UniversalValueIsFixed" xml:space="preserve">
-    <value>Tags with TagClass Universal must have the appropriate TagValue value for the data type being read or written.</value>
-  </data>
-  <data name="Cryptography_Asn_UnusedBitCountRange" xml:space="preserve">
-    <value>Unused bit count must be between 0 and 7, inclusive.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_EncodeUnbalancedStack" xml:space="preserve">
-    <value>Encode cannot be called while a Sequence or SetOf is still open.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_PopWrongTag" xml:space="preserve">
-    <value>Cannot pop the requested tag as it is not currently in progress.</value>
-  </data>
   <data name="Cryptography_NotValidPublicOrPrivateKey" xml:space="preserve">
     <value>Key is not a valid public or private key.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.Pkcs/src/Resources/Strings.resx
index 0b0701deadb05b..c85300da29d680 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.Pkcs/src/Resources/Strings.resx
@@ -88,27 +88,6 @@
   <data name="Cryptography_AlgKdfRequiresChars" xml:space="preserve">
     <value>The KDF for algorithm '{0}' requires a char-based password input.</value>
   </data>
-  <data name="Cryptography_Asn_EnumeratedValueRequiresNonFlagsEnum" xml:space="preserve">
-    <value>ASN.1 Enumerated values only apply to enum types without the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListRequiresFlagsEnum" xml:space="preserve">
-    <value>Named bit list operations require an enum with the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListValueTooBig" xml:space="preserve">
-    <value>The encoded named bit list value is larger than the value size of the '{0}' enum.</value>
-  </data>
-  <data name="Cryptography_Asn_UniversalValueIsFixed" xml:space="preserve">
-    <value>Tags with TagClass Universal must have the appropriate TagValue value for the data type being read or written.</value>
-  </data>
-  <data name="Cryptography_Asn_UnusedBitCountRange" xml:space="preserve">
-    <value>Unused bit count must be between 0 and 7, inclusive.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_EncodeUnbalancedStack" xml:space="preserve">
-    <value>Encode cannot be called while a Sequence or SetOf is still open.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_PopWrongTag" xml:space="preserve">
-    <value>Cannot pop the requested tag as it is not currently in progress.</value>
-  </data>
   <data name="Cryptography_BadHashValue" xml:space="preserve">
     <value>The hash value is not correct.</value>
   </data>
@@ -289,9 +268,6 @@
   <data name="Cryptography_UnknownHashAlgorithm" xml:space="preserve">
     <value>'{0}' is not a known hash algorithm.</value>
   </data>
-  <data name="Cryptography_WriteEncodedValue_OneValueAtATime" xml:space="preserve">
-    <value>The input to WriteEncodedValue must represent a single encoded value with no trailing data.</value>
-  </data>
   <data name="Cryptography_Cms_NoAttributeFound" xml:space="preserve">
     <value>Attribute not found.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
index b7e39a57646cf4..5b241ff7afc482 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
@@ -115,12 +115,6 @@
   <data name="Chain_RevocationStatusUnknown" xml:space="preserve">
     <value>The certificate's revocation status could not be determined.</value>
   </data>
-  <data name="Chain_SettingNotSupported" xml:space="preserve">
-    <value>The certificate chain setting '{0}' is not supported on this platform.</value>
-  </data>
-  <data name="Chain_VerificationFlagNotSupported" xml:space="preserve">
-    <value>The verification flag '{0}' is not supported on this platform.</value>
-  </data>
   <data name="Cryptography_BadHashSize_ForAlgorithm" xml:space="preserve">
     <value>The provided value of {0} bytes does not match the expected size of {1} bytes for the algorithm ({2}).</value>
   </data>
@@ -136,9 +130,6 @@
   <data name="Cryptography_CertReq_DatesReversed" xml:space="preserve">
     <value>The provided notBefore value is later than the notAfter value.</value>
   </data>
-  <data name="Cryptography_CertReq_DateTooOld" xml:space="preserve">
-    <value>The value predates 1950 and has no defined encoding.</value>
-  </data>
   <data name="Cryptography_CertReq_DuplicateExtension" xml:space="preserve">
     <value>An X509Extension with OID '{0}' has already been specified.</value>
   </data>
@@ -196,9 +187,6 @@
   <data name="Cryptography_InvalidPaddingMode" xml:space="preserve">
     <value>Specified padding mode is not valid for this algorithm.</value>
   </data>
-  <data name="Cryptography_InvalidPublicKey_Object" xml:space="preserve">
-    <value>The provided PublicKey object is invalid, valid Oid and EncodedKeyValue property values are required.</value>
-  </data>
   <data name="Cryptography_InvalidRsaParameters" xml:space="preserve">
     <value>The specified RSA parameters are not valid. Exponent and Modulus are required. If D is present, it must have the same length as Modulus. If D is present, P, Q, DP, DQ, and InverseQ are required and must have half the length of Modulus, rounded up, otherwise they must be omitted.</value>
   </data>
@@ -349,9 +337,6 @@
   <data name="NotSupported_ECDiffieHellman_Csp" xml:space="preserve">
     <value>CryptoApi ECDiffieHellman keys are not supported.</value>
   </data>
-  <data name="NotSupported_Export_MultiplePrivateCerts" xml:space="preserve">
-    <value>Only one certificate with a private key can be exported in a single PFX.</value>
-  </data>
   <data name="NotSupported_KeyAlgorithm" xml:space="preserve">
     <value>The certificate key algorithm is not supported.</value>
   </data>
@@ -430,30 +415,6 @@
   <data name="Cryptography_InvalidDsaParameters_QRestriction_LargeKey" xml:space="preserve">
     <value>The specified DSA parameters are not valid; Q's length must be one of 20, 32 or 64 bytes.</value>
   </data>
-  <data name="Cryptography_WriteEncodedValue_OneValueAtATime" xml:space="preserve">
-    <value>The input to WriteEncodedValue must represent a single encoded value with no trailing data.</value>
-  </data>
-  <data name="Cryptography_Asn_EnumeratedValueRequiresNonFlagsEnum" xml:space="preserve">
-    <value>ASN.1 Enumerated values only apply to enum types without the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListRequiresFlagsEnum" xml:space="preserve">
-    <value>Named bit list operations require an enum with the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListValueTooBig" xml:space="preserve">
-    <value>The encoded named bit list value is larger than the value size of the '{0}' enum.</value>
-  </data>
-  <data name="Cryptography_Asn_UniversalValueIsFixed" xml:space="preserve">
-    <value>Tags with TagClass Universal must have the appropriate TagValue value for the data type being read or written.</value>
-  </data>
-  <data name="Cryptography_Asn_UnusedBitCountRange" xml:space="preserve">
-    <value>Unused bit count must be between 0 and 7, inclusive.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_EncodeUnbalancedStack" xml:space="preserve">
-    <value>Encode cannot be called while a Sequence or SetOf is still open.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_PopWrongTag" xml:space="preserve">
-    <value>Cannot pop the requested tag as it is not currently in progress.</value>
-  </data>
   <data name="Cryptography_NotValidPublicOrPrivateKey" xml:space="preserve">
     <value>Key is not a valid public or private key.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/tests/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.X509Certificates/tests/Resources/Strings.resx
index 00e896df64b5b6..684a789df83a61 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/tests/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/tests/Resources/Strings.resx
@@ -69,90 +69,12 @@
   <data name="Argument_InvalidOidValue" xml:space="preserve">
     <value>The OID value was invalid.</value>
   </data>
-  <data name="Cryptography_Asn_EnumeratedValueRequiresNonFlagsEnum" xml:space="preserve">
-    <value>ASN.1 Enumerated values only apply to enum types without the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListRequiresFlagsEnum" xml:space="preserve">
-    <value>Named bit list operations require an enum with the [Flags] attribute.</value>
-  </data>
-  <data name="Cryptography_Asn_NamedBitListValueTooBig" xml:space="preserve">
-    <value>The encoded named bit list value is larger than the value size of the '{0}' enum.</value>
-  </data>
-  <data name="Cryptography_Asn_UniversalValueIsFixed" xml:space="preserve">
-    <value>Tags with TagClass Universal must have the appropriate TagValue value for the data type being read or written.</value>
-  </data>
-  <data name="Cryptography_Asn_UnusedBitCountRange" xml:space="preserve">
-    <value>Unused bit count must be between 0 and 7, inclusive.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_AmbiguousFieldType" xml:space="preserve">
-    <value>Field '{0}' of type '{1}' has ambiguous type '{2}', an attribute derived from AsnTypeAttribute is required.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Choice_AllowNullNonNullable" xml:space="preserve">
-    <value>[Choice].AllowNull=true is not valid because type '{0}' cannot have a null value.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Choice_ConflictingTagMapping" xml:space="preserve">
-    <value>The tag ({0} {1}) for field '{2}' on type '{3}' already is associated in this context with field '{4}' on type '{5}'.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Choice_DefaultValueDisallowed" xml:space="preserve">
-    <value>Field '{0}' on [Choice] type '{1}' has a default value, which is not permitted.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Choice_NoChoiceWasMade" xml:space="preserve">
-    <value>An instance of [Choice] type '{0}' has no non-null fields.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Choice_NonNullableField" xml:space="preserve">
-    <value>Field '{0}' on [Choice] type '{1}' can not be assigned a null value.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Choice_TooManyValues" xml:space="preserve">
-    <value>Fields '{0}' and '{1}' on type '{2}' are both non-null when only one value is permitted.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Choice_TypeCycle" xml:space="preserve">
-    <value>Field '{0}' on [Choice] type '{1}' has introduced a type chain cycle.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_MultipleAsnTypeAttributes" xml:space="preserve">
-    <value>Field '{0}' on type '{1}' has multiple attributes deriving from '{2}' when at most one is permitted.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_NoJaggedArrays" xml:space="preserve">
-    <value>Type '{0}' cannot be serialized or deserialized because it is an array of arrays.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_NoMultiDimensionalArrays" xml:space="preserve">
-    <value>Type '{0}' cannot be serialized or deserialized because it is a multi-dimensional array.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_NoOpenTypes" xml:space="preserve">
-    <value>Type '{0}' cannot be serialized or deserialized because it is not sealed or has unbound generic parameters.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_Optional_NonNullableField" xml:space="preserve">
-    <value>Field '{0}' on type '{1}' is declared [OptionalValue], but it can not be assigned a null value.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_SetValueException" xml:space="preserve">
-    <value>Unable to set field {0} on type {1}.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_SpecificTagChoice" xml:space="preserve">
-    <value>Field '{0}' on type '{1}' has specified an implicit tag value via [ExpectedTag] for [Choice] type '{2}'. ExplicitTag must be true, or the [ExpectedTag] attribute removed.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_UnexpectedTypeForAttribute" xml:space="preserve">
-    <value>Field '{0}' of type '{1}' has an effective type of '{2}' when one of ({3}) was expected.</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_UtcTimeTwoDigitYearMaxTooSmall" xml:space="preserve">
-    <value>Field '{0}' on type '{1}' has a [UtcTime] TwoDigitYearMax value ({2}) smaller than the minimum (99).</value>
-  </data>
-  <data name="Cryptography_AsnSerializer_UnhandledType" xml:space="preserve">
-    <value>Could not determine how to serialize or deserialize type '{0}'.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_EncodeUnbalancedStack" xml:space="preserve">
-    <value>Encode cannot be called while a Sequence or SetOf is still open.</value>
-  </data>
-  <data name="Cryptography_AsnWriter_PopWrongTag" xml:space="preserve">
-    <value>Cannot pop the requested tag as it is not currently in progress.</value>
-  </data>
   <data name="Cryptography_Der_Invalid_Encoding" xml:space="preserve">
     <value>ASN1 corrupted data.</value>
   </data>
   <data name="Cryptography_Invalid_IA5String" xml:space="preserve">
     <value>The string contains a character not in the 7 bit ASCII character set.</value>
   </data>
-  <data name="Cryptography_WriteEncodedValue_OneValueAtATime" xml:space="preserve">
-    <value>The input to WriteEncodedValue must represent a single encoded value with no trailing data.</value>
-  </data>
   <data name="Cryptography_X509Store_WouldModifyUserTrust" xml:space="preserve">
     <value>Removing the requested certificate would modify user trust settings, and has been denied.</value>
   </data>
diff --git a/src/libraries/System.ServiceModel.Syndication/src/Resources/Strings.resx b/src/libraries/System.ServiceModel.Syndication/src/Resources/Strings.resx
index 6ac5b01d1c5a4b..03d0e81ba8220f 100644
--- a/src/libraries/System.ServiceModel.Syndication/src/Resources/Strings.resx
+++ b/src/libraries/System.ServiceModel.Syndication/src/Resources/Strings.resx
@@ -188,9 +188,6 @@
   <data name="UnsupportedRssVersion" xml:space="preserve">
     <value>The Rss20Serializer does not support RSS version '{0}'.</value>
   </data>
-  <data name="UriGeneratorSchemeMustNotBeEmpty" xml:space="preserve">
-    <value>The scheme parameter must not be empty.</value>
-  </data>
   <data name="ValueMustBeNonNegative" xml:space="preserve">
     <value>The value of this argument must be non-negative.</value>
   </data>
diff --git a/src/libraries/System.Text.Json/src/Resources/Strings.resx b/src/libraries/System.Text.Json/src/Resources/Strings.resx
index 40cd01f21877b3..c8759d3fe2710d 100644
--- a/src/libraries/System.Text.Json/src/Resources/Strings.resx
+++ b/src/libraries/System.Text.Json/src/Resources/Strings.resx
@@ -539,9 +539,6 @@
   <data name="SerializerConverterFactoryReturnsJsonConverterFactory" xml:space="preserve">
     <value>The converter '{0}' cannot return an instance of JsonConverterFactory.</value>
   </data>
-  <data name="NodeDynamicObjectResultNotAssignable" xml:space="preserve">
-    <value>The result type '{0}' of the dynamic binding produced by the object with type '{1}' for the binder '{2}' is not compatible with the result type '{3}' expected by the call site.</value>
-  </data>
   <data name="NodeElementWrongType" xml:space="preserve">
     <value>The element must be of type '{0}'</value>
   </data>
@@ -575,9 +572,6 @@
   <data name="OptionsAlreadyBoundToContext" xml:space="preserve">
     <value>"The specified 'JsonSerializerOptions' instance is already bound with a 'JsonSerializerContext' instance."</value>
   </data>
-  <data name="InitializeTypeInfoAsObjectInvalid" xml:space="preserve">
-    <value>The value must represent an object type.</value>
-  </data>
   <data name="ConverterForPropertyMustBeValid" xml:space="preserve">
     <value>The generic type of the converter for property '{0}.{1}' must match with the specified converter type '{2}'. The converter must not be 'null'.</value>
   </data>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/Strings.resx b/src/libraries/System.Text.RegularExpressions/gen/Resources/Strings.resx
index 72dedb53b0b910..e55d4cc47ba303 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/Strings.resx
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/Strings.resx
@@ -155,9 +155,6 @@
   <data name="Arg_ArrayPlusOffTooSmall" xml:space="preserve">
     <value>Destination array is not long enough to copy all the items in the collection. Check array index and length.</value>
   </data>
-  <data name="ArgumentNull_ArrayWithNullElements" xml:space="preserve">
-    <value>The array cannot contain null elements.</value>
-  </data>
   <data name="ShorthandClassInCharacterRange" xml:space="preserve">
     <value>Cannot include class \\{0} in character range.</value>
   </data>
@@ -241,9 +238,6 @@
   <data name="NotSupported_ReadOnlyCollection" xml:space="preserve">
     <value>Collection is read-only.</value>
   </data>
-  <data name="OnlyAllowedOnce" xml:space="preserve">
-    <value>This operation is only allowed once per object.</value>
-  </data>
   <data name="PlatformNotSupported_CompileToAssembly" xml:space="preserve">
     <value>This platform does not support writing compiled regular expressions to an assembly.</value>
   </data>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.cs.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.cs.xlf
index 670114d466a8f9..c2968a51431064 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.cs.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.cs.xlf
@@ -47,11 +47,6 @@
         <target state="translated">Cílové pole není dostatečně dlouhé, aby bylo možné zkopírovat všechny položky v kolekci. Zkontrolujte index a délku pole.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">Pole nemůže obsahovat elementy null.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">Počáteční index nemůže být menší než nula nebo větší než délka vstupu.</target>
@@ -212,11 +207,6 @@
         <target state="translated">Kolekce je jen pro čtení.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Tuto operaci lze na objektu provést pouze jednou.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Tato platforma nepodporuje zápis zkompilovaných regulárních výrazů do sestavení.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.de.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.de.xlf
index decb3d41eecab9..9f5482f421bcc0 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.de.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.de.xlf
@@ -47,11 +47,6 @@
         <target state="translated">Das Zielarray ist nicht lang genug, um alle Elemente in der Sammlung zu kopieren. Prüfen Sie den Index und die Länge des Arrays.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">Das Array kann keine NULL-Elemente enthalten.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">Der Startindex darf nicht kleiner als 0 oder größer als die Eingabelänge sein.</target>
@@ -212,11 +207,6 @@
         <target state="translated">Die Sammlung ist schreibgeschützt.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Dieser Vorgang ist pro Objekt nur einmal zulässig.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Diese Plattform unterstützt das Schreiben kompilierter regulärer Ausdrücke in eine Assembly nicht.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.es.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.es.xlf
index dfcb4b46eb8cbb..1f47b5de7d2266 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.es.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.es.xlf
@@ -47,11 +47,6 @@
         <target state="translated">La matriz de destino no es lo suficientemente larga para copiar todos los elementos de la colección. Compruebe el índice y la longitud de la matriz.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">La matriz no puede contener elementos null.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">El índice inicial no puede ser inferior a 0 ni superior a la longitud de entrada.</target>
@@ -212,11 +207,6 @@
         <target state="translated">La colección es de sólo lectura.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Esta operación sólo se permite una vez por cada objeto.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Esta plataforma no admite la escritura de expresiones regulares compiladas en un ensamblado.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.fr.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.fr.xlf
index 0413c2f3697287..aa03be1e1cd029 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.fr.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.fr.xlf
@@ -47,11 +47,6 @@
         <target state="translated">La taille du tableau de destination ne permet pas de copier tous les éléments de la collection. Vérifiez l'index et la longueur du tableau.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">Le tableau ne peut pas contenir d'éléments null.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">L'index de début ne peut pas être inférieur à 0 ou supérieur à la longueur d'entrée.</target>
@@ -212,11 +207,6 @@
         <target state="translated">La collection est en lecture seule.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Cette opération n'est autorisée qu'une fois par objet.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Cette plateforme ne prend pas en charge l’écriture d’expressions régulières compilées dans un assembly.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.it.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.it.xlf
index 2f32980d35f71f..b92ba1bea75644 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.it.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.it.xlf
@@ -47,11 +47,6 @@
         <target state="translated">La lunghezza della matrice di destinazione non è sufficiente per copiare tutti gli elementi della raccolta. Controllare l'indice e la lunghezza della matrice.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">La matrice non può contenere elementi Null.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">L'indirizzo di inizio non può essere minore di zero o maggiore della lunghezza di input.</target>
@@ -212,11 +207,6 @@
         <target state="translated">La raccolta è di sola lettura.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Questa operazione può essere eseguita una sola volta per oggetto.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Questa piattaforma non supporta la scrittura di espressioni regolari compilate in un assembly.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ja.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ja.xlf
index 8dddebb2d887ec..91c211945afbeb 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ja.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ja.xlf
@@ -47,11 +47,6 @@
         <target state="translated">ターゲット配列の長さが不足しているため、コレクション内のすべての項目をコピーできません。配列のインデックスと長さをご確認ください。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">配列に null 要素を含めることはできません。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">開始インデックスに 0 より小さい値または入力長より大きい値を指定することはできません。</target>
@@ -212,11 +207,6 @@
         <target state="translated">コレクションは読み取り専用です。</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">この操作は、オブジェクトに付き 1 回のみ実行できます。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">このプラットフォームでは、コンパイルされた正規表現をアセンブリに書き込むことはサポートされていません。</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ko.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ko.xlf
index 369483d521ad69..1c8f8666d267aa 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ko.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ko.xlf
@@ -47,11 +47,6 @@
         <target state="translated">대상 배열이 컬렉션의 모든 항목을 복사하기에 충분히 길지 않습니다. 배열 인덱스와 길이를 확인하세요.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">배열에는 null 요소가 포함될 수 없습니다.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">시작 인덱스는 0보다 작거나 입력 길이보다 클 수 없습니다.</target>
@@ -212,11 +207,6 @@
         <target state="translated">읽기 전용 컬렉션입니다.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">이 작업은 개체 당 한 번만 사용할 수 있습니다.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">이 플랫폼은 컴파일된 정규식을 어셈블리에 쓰는 것을 지원하지 않습니다.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pl.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pl.xlf
index 01efb83445bb5e..e92384e78130c8 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pl.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pl.xlf
@@ -47,11 +47,6 @@
         <target state="translated">Tablica docelowa ma zbyt małą długość, aby móc skopiować wszystkie elementy kolekcji. Sprawdź indeks tablicy i jej długość.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">Tablica nie może zawierać elementów zerowych.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">Indeks początkowy nie może być mniejszy od 0 ani większy od długości danych wejściowych.</target>
@@ -212,11 +207,6 @@
         <target state="translated">Kolekcja jest tylko do odczytu.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Ta operacja jest dozwolona tylko raz dla każdego obiektu.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Ta platforma nie obsługuje pisania skompilowanych wyrażeń regularnych do zestawu.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pt-BR.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pt-BR.xlf
index 9f039335387e4a..373012b1916013 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pt-BR.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.pt-BR.xlf
@@ -47,11 +47,6 @@
         <target state="translated">A matriz de destino não é longa o suficiente para copiar todos os itens da coleção. Verifique o índice e o tamanho da matriz.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">A matriz não pode conter elementos nulos.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">Índice inicial não pode ser menor que 0 ou maior que o comprimento de entrada.</target>
@@ -212,11 +207,6 @@
         <target state="translated">A coleção é somente leitura.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Esta operação só é permitida uma vez por objeto.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Essa plataforma não suporta a escrita de expressões regulares compiladas em um assembly.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ru.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ru.xlf
index 5adb41132357ce..cf5dd334da3480 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ru.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.ru.xlf
@@ -47,11 +47,6 @@
         <target state="translated">Длина конечного массива недостаточна для копирования всех элементов коллекции. Проверьте индекс и длину массива.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">Массив не может содержать null-элементы.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">Начальный индекс не может быть меньше 0 или больше длины ввода.</target>
@@ -212,11 +207,6 @@
         <target state="translated">Данная коллекция предназначена только для чтения.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Для каждого объекта допускается только однократное выполнение этой операции.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Эта платформа не поддерживает запись скомпилированных регулярных выражений в сборку.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.tr.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.tr.xlf
index 9622b266daee22..3ef9a801e79a71 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.tr.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.tr.xlf
@@ -47,11 +47,6 @@
         <target state="translated">Hedef dizi, koleksiyondaki tüm öğeleri kopyalamak için yeterince uzun değil. Dizi dizinini ve uzunluğunu denetleyin.</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">Dizi null öğeler içeremez.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">Başlangıç dizini sıfırdan küçük veya giriş uzunluğundan büyük olamaz.</target>
@@ -212,11 +207,6 @@
         <target state="translated">Koleksiyon salt okunur.</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">Bu işleme her nesne için yalnızca bir kez izin verilir.</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">Bu platform, bütünleştirilmiş koda derlenmiş normal ifadeler yazılmasını desteklemiyor.</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hans.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hans.xlf
index 6b007977907ab5..a9909ca0f357be 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hans.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hans.xlf
@@ -47,11 +47,6 @@
         <target state="translated">目标数组不够长，无法复制集合中的所有项。请检查数组索引和长度。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">数组不能包含 null 元素。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">起始索引不能小于 0 或大于输入长度。</target>
@@ -212,11 +207,6 @@
         <target state="translated">集合是只读的。</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">对每个对象只能执行一次此操作。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">此平台不支持将已编译的正则表达式写入程序集。</target>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hant.xlf b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hant.xlf
index 7972b6b990e627..81971ed58e209a 100644
--- a/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hant.xlf
+++ b/src/libraries/System.Text.RegularExpressions/gen/Resources/xlf/Strings.zh-Hant.xlf
@@ -47,11 +47,6 @@
         <target state="translated">目的地陣列的長度不足以複製集合中的所有項目。請檢查陣列索引以及長度。</target>
         <note />
       </trans-unit>
-      <trans-unit id="ArgumentNull_ArrayWithNullElements">
-        <source>The array cannot contain null elements.</source>
-        <target state="translated">陣列不可包含 null 元素。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="BeginIndexNotNegative">
         <source>Start index cannot be less than 0 or greater than input length.</source>
         <target state="translated">起始索引不能小於 0 或大於輸入長度。</target>
@@ -212,11 +207,6 @@
         <target state="translated">集合是唯讀的。</target>
         <note />
       </trans-unit>
-      <trans-unit id="OnlyAllowedOnce">
-        <source>This operation is only allowed once per object.</source>
-        <target state="translated">每一個物件只允許執行此項作業一次。</target>
-        <note />
-      </trans-unit>
       <trans-unit id="PlatformNotSupported_CompileToAssembly">
         <source>This platform does not support writing compiled regular expressions to an assembly.</source>
         <target state="translated">此平台不支援將已編譯的規則運算式寫入組件。</target>
diff --git a/src/libraries/System.Text.RegularExpressions/src/Resources/Strings.resx b/src/libraries/System.Text.RegularExpressions/src/Resources/Strings.resx
index 52b6616648dd28..154f34512ed1e2 100644
--- a/src/libraries/System.Text.RegularExpressions/src/Resources/Strings.resx
+++ b/src/libraries/System.Text.RegularExpressions/src/Resources/Strings.resx
@@ -70,9 +70,6 @@
   <data name="Arg_ArrayPlusOffTooSmall" xml:space="preserve">
     <value>Destination array is not long enough to copy all the items in the collection. Check array index and length.</value>
   </data>
-  <data name="ArgumentNull_ArrayWithNullElements" xml:space="preserve">
-    <value>The array cannot contain null elements.</value>
-  </data>
   <data name="ShorthandClassInCharacterRange" xml:space="preserve">
     <value>Cannot include class \\{0} in character range.</value>
   </data>
diff --git a/src/libraries/System.Threading.Tasks.Dataflow/src/Resources/Strings.resx b/src/libraries/System.Threading.Tasks.Dataflow/src/Resources/Strings.resx
index 0c233f2bf9b4f2..d8f878ef5201c4 100644
--- a/src/libraries/System.Threading.Tasks.Dataflow/src/Resources/Strings.resx
+++ b/src/libraries/System.Threading.Tasks.Dataflow/src/Resources/Strings.resx
@@ -93,9 +93,6 @@
   <data name="NotSupported_MemberNotNeeded" xml:space="preserve">
     <value>This member is not supported on this dataflow block. The block is intended for a specific purpose that does not utilize this member.</value>
   </data>
-  <data name="ConcurrentCollection_SyncRoot_NotSupported" xml:space="preserve">
-    <value>The SyncRoot property may not be used for the synchronization of concurrent collections.</value>
-  </data>
   <data name="InvalidOperation_ErrorDuringCleanup" xml:space="preserve">
     <value>An error occurred while linking up the target or during the cleanup after completion.</value>
   </data>

From bd84729d1a31e7df8f8f3ea8134e6762ee44b671 Mon Sep 17 00:00:00 2001
From: Andrii Kurdiumov <kant2002@gmail.com>
Date: Fri, 28 Jan 2022 00:48:49 +0600
Subject: [PATCH 114/161] Fix minor things in comments to DllImportGenerator
 (#64088)

---
 .../Marshalling/ArrayMarshaller.cs                              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ArrayMarshaller.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ArrayMarshaller.cs
index ec42fcd838f844..569db790ffe701 100644
--- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ArrayMarshaller.cs
+++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ArrayMarshaller.cs
@@ -96,7 +96,7 @@ private IEnumerable<StatementSyntax> GeneratePinningPath(TypePositionInfo info,
                 // of an array as long as it is non-null, matching the behavior of the built-in interop system
                 // for single-dimensional zero-based arrays.
 
-                // ref <elementType> <byRefIdentifier> = <managedIdentifer> == null ? ref *(<elementType*)0 : ref MemoryMarshal.GetArrayDataReference(<managedIdentifer>);
+                // ref <elementType> <byRefIdentifier> = ref <managedIdentifer> == null ? ref *(<elementType>*)0 : ref MemoryMarshal.GetArrayDataReference(<managedIdentifer>);
                 PrefixUnaryExpressionSyntax nullRef =
                     PrefixUnaryExpression(SyntaxKind.PointerIndirectionExpression,
                         CastExpression(

From 5409d71a9c77d2ff45a4346fba1036734ffae0bc Mon Sep 17 00:00:00 2001
From: Egor Bogatov <egorbo@gmail.com>
Date: Thu, 27 Jan 2022 21:56:17 +0300
Subject: [PATCH 115/161] ARM64: Avoid LEA for volatile IND (#64354)

Co-authored-by: Kunal Pathak <Kunal.Pathak@microsoft.com>
---
 src/coreclr/jit/lower.cpp      | 25 ++++++++++++++++++-------
 src/coreclr/jit/lower.h        |  2 +-
 src/coreclr/jit/lowerxarch.cpp |  6 +++---
 3 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/coreclr/jit/lower.cpp b/src/coreclr/jit/lower.cpp
index d19e1460c4a035..ed71bb09c4aa56 100644
--- a/src/coreclr/jit/lower.cpp
+++ b/src/coreclr/jit/lower.cpp
@@ -4891,20 +4891,29 @@ bool Lowering::AreSourcesPossiblyModifiedLocals(GenTree* addr, GenTree* base, Ge
 //    addressing mode and transform them to a GT_LEA
 //
 // Arguments:
-//    use - the use of the address we want to transform
+//    addr - the use of the address we want to transform
 //    isContainable - true if this addressing mode can be contained
-//    targetType - on arm we can use "scale" only for appropriate target type
+//    parent - the node that consumes the given addr (most likely it's an IND)
 //
 // Returns:
 //    true if the address node was changed to a LEA, false otherwise.
 //
-bool Lowering::TryCreateAddrMode(GenTree* addr, bool isContainable, var_types targetType)
+bool Lowering::TryCreateAddrMode(GenTree* addr, bool isContainable, GenTree* parent)
 {
     if (!addr->OperIs(GT_ADD) || addr->gtOverflow())
     {
         return false;
     }
 
+#ifdef TARGET_ARM64
+    if (parent->OperIsIndir() && parent->AsIndir()->IsVolatile())
+    {
+        // For Arm64 we avoid using LEA for volatile INDs
+        // because we won't be able to use ldar/star
+        return false;
+    }
+#endif
+
     GenTree* base   = nullptr;
     GenTree* index  = nullptr;
     unsigned scale  = 0;
@@ -4920,6 +4929,8 @@ bool Lowering::TryCreateAddrMode(GenTree* addr, bool isContainable, var_types ta
                                                        &scale,   // scaling
                                                        &offset); // displacement
 
+    var_types targetType = parent->OperIsIndir() ? parent->TypeGet() : TYP_UNDEF;
+
 #ifdef TARGET_ARMARCH
     // Multiplier should be a "natural-scale" power of two number which is equal to target's width.
     //
@@ -5109,7 +5120,7 @@ GenTree* Lowering::LowerAdd(GenTreeOp* node)
             GenTree* parent = use.User();
             if (!parent->OperIsIndir() && !parent->OperIs(GT_ADD))
             {
-                TryCreateAddrMode(node, false);
+                TryCreateAddrMode(node, false, parent);
             }
         }
 #endif // !TARGET_ARMARCH
@@ -6778,7 +6789,7 @@ void Lowering::ContainCheckBitCast(GenTree* node)
 void Lowering::LowerStoreIndirCommon(GenTreeStoreInd* ind)
 {
     assert(ind->TypeGet() != TYP_STRUCT);
-    TryCreateAddrMode(ind->Addr(), true, ind->TypeGet());
+    TryCreateAddrMode(ind->Addr(), true, ind);
     if (!comp->codeGen->gcInfo.gcIsWriteBarrierStoreIndNode(ind))
     {
         if (varTypeIsFloating(ind) && ind->Data()->IsCnsFltOrDbl())
@@ -6846,7 +6857,7 @@ void Lowering::LowerIndir(GenTreeIndir* ind)
         // TODO-Cleanup: We're passing isContainable = true but ContainCheckIndir rejects
         // address containment in some cases so we end up creating trivial (reg + offfset)
         // or (reg + reg) LEAs that are not necessary.
-        TryCreateAddrMode(ind->Addr(), true, ind->TypeGet());
+        TryCreateAddrMode(ind->Addr(), true, ind);
         ContainCheckIndir(ind);
 
         if (ind->OperIs(GT_NULLCHECK) || ind->IsUnusedValue())
@@ -6859,7 +6870,7 @@ void Lowering::LowerIndir(GenTreeIndir* ind)
         // If the `ADDR` node under `STORE_OBJ(dstAddr, IND(struct(ADDR))`
         // is a complex one it could benefit from an `LEA` that is not contained.
         const bool isContainable = false;
-        TryCreateAddrMode(ind->Addr(), isContainable, ind->TypeGet());
+        TryCreateAddrMode(ind->Addr(), isContainable, ind);
     }
 }
 
diff --git a/src/coreclr/jit/lower.h b/src/coreclr/jit/lower.h
index 624cc1372dc5a9..95843b6bded47e 100644
--- a/src/coreclr/jit/lower.h
+++ b/src/coreclr/jit/lower.h
@@ -307,7 +307,7 @@ class Lowering final : public Phase
     void ContainBlockStoreAddress(GenTreeBlk* blkNode, unsigned size, GenTree* addr);
     void LowerPutArgStk(GenTreePutArgStk* tree);
 
-    bool TryCreateAddrMode(GenTree* addr, bool isContainable, var_types targetType = TYP_UNDEF);
+    bool TryCreateAddrMode(GenTree* addr, bool isContainable, GenTree* parent);
 
     bool TryTransformStoreObjAsStoreInd(GenTreeBlk* blkNode);
 
diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp
index 1331644a0a992b..37459907558a0b 100644
--- a/src/coreclr/jit/lowerxarch.cpp
+++ b/src/coreclr/jit/lowerxarch.cpp
@@ -194,7 +194,7 @@ GenTree* Lowering::LowerBinaryArithmetic(GenTreeOp* binOp)
 //
 void Lowering::LowerBlockStore(GenTreeBlk* blkNode)
 {
-    TryCreateAddrMode(blkNode->Addr(), false);
+    TryCreateAddrMode(blkNode->Addr(), false, blkNode);
 
     GenTree* dstAddr = blkNode->Addr();
     GenTree* src     = blkNode->Data();
@@ -408,7 +408,7 @@ void Lowering::ContainBlockStoreAddress(GenTreeBlk* blkNode, unsigned size, GenT
         return;
     }
 
-    if (!addr->OperIsAddrMode() && !TryCreateAddrMode(addr, true))
+    if (!addr->OperIsAddrMode() && !TryCreateAddrMode(addr, true, blkNode))
     {
         return;
     }
@@ -5799,7 +5799,7 @@ bool Lowering::TryGetContainableHWIntrinsicOp(GenTreeHWIntrinsic* containingNode
 void Lowering::ContainCheckHWIntrinsicAddr(GenTreeHWIntrinsic* node, GenTree* addr)
 {
     assert((addr->TypeGet() == TYP_I_IMPL) || (addr->TypeGet() == TYP_BYREF));
-    TryCreateAddrMode(addr, true);
+    TryCreateAddrMode(addr, true, node);
     if ((addr->OperIs(GT_CLS_VAR_ADDR, GT_LCL_VAR_ADDR, GT_LCL_FLD_ADDR, GT_LEA) ||
          (addr->IsCnsIntOrI() && addr->AsIntConCommon()->FitsInAddrBase(comp))) &&
         IsSafeToContainMem(node, addr))

From fe0d9200f4bf3cf5324ea32d8199cee1cb4712d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aleksey=20Kliger=20=28=CE=BBgeek=29?= <alklig@microsoft.com>
Date: Thu, 27 Jan 2022 14:16:21 -0500
Subject: [PATCH 116/161] [docs] Collecting stack traces with native symbols on
 WebAssembly (#64383)

* [docs] Collecting stack traces with native symbols on WebAssembly

* Apply suggestions from code review

Co-authored-by: Larry Ewing <lewing@microsoft.com>
Co-authored-by: Ankit Jain <radical@gmail.com>

Co-authored-by: Larry Ewing <lewing@microsoft.com>
Co-authored-by: Ankit Jain <radical@gmail.com>
---
 .../workflow/debugging/mono/wasm-debugging.md | 130 +++++++++++++++++-
 1 file changed, 129 insertions(+), 1 deletion(-)

diff --git a/docs/workflow/debugging/mono/wasm-debugging.md b/docs/workflow/debugging/mono/wasm-debugging.md
index cfc98c1be2dbd7..4e7945ce515b6d 100644
--- a/docs/workflow/debugging/mono/wasm-debugging.md
+++ b/docs/workflow/debugging/mono/wasm-debugging.md
@@ -2,7 +2,7 @@
 WASM runtime debugging
 ======================
 
-- Disable symbol stripping by setting the `WasmNativeStrip` msbuild property to `false`.
+- Disable symbol stripping by setting the `WasmNativeStrip` msbuild property to `false`.  See also, [collecting stack traces with symbols in Blazor](#collecting-stack-traces-with-symbols-in-blazor)
 
 - Emscripten generates dwarf debug info and Chrome 80 and later can use it.
 
@@ -133,3 +133,131 @@ These kinds of faults usually happen because the mono runtime has some helper fu
 never meant to be reached, i.e. `no_gsharedvt_in_wrapper` or `no_llvmonly_interp_method_pointer`.
 These functions are used as placeholders for function pointers with different signatures, so
 if they do end up being called due to a bug, a signature mismatch error happens.
+
+# Collecting stack traces with symbols in Blazor
+
+When debugging a native crash in a .NET 6 Blazor app or another WebAssembly
+framework that uses our default `dotnet.wasm`, the native stack frames will not
+have C symbol names, but will instead look like `$func1234`.
+
+For example this Razor page will crash when a user clicks on the `Crash` button
+
+```csharp
+<button class="btn btn-warning" @onclick="Crash">Crash</button>
+
+@code {
+    private void Crash ()
+    {
+        IntPtr p = (IntPtr)0x01;
+        Console.WriteLine ("About to crash");
+        System.Runtime.InteropServices.Marshal.FreeHGlobal(p);
+    }
+}
+```
+
+Clicking on the `Crash` button will produce the following output in the console (the function indices may be different):
+
+```console
+dotnet.wasm:0x1d8355 Uncaught (in promise) RuntimeError: memory access out of bounds
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+    at _framework/dotnet.wasm
+$free @ dotnet.wasm:0x1d8355
+$func4027 @ dotnet.wasm:0xead6a
+$func219 @ dotnet.wasm:0x1a03a
+$func167 @ dotnet.wasm:0xcaf7
+$func166 @ dotnet.wasm:0xba0a
+$func2810 @ dotnet.wasm:0xabacf
+$func1615 @ dotnet.wasm:0x6f8eb
+$func1613 @ dotnet.wasm:0x6f85d
+$func966 @ dotnet.wasm:0x502dc
+$func219 @ dotnet.wasm:0x1a0e2
+$func167 @ dotnet.wasm:0xcaf7
+$func166 @ dotnet.wasm:0xba0a
+$func2810 @ dotnet.wasm:0xabacf
+$func1615 @ dotnet.wasm:0x6f8eb
+$func1619 @ dotnet.wasm:0x6ff58
+$mono_wasm_invoke_method @ dotnet.wasm:0x96c9
+Module._mono_wasm_invoke_method @ dotnet.6.0.1.hopd7ipo8x.js:1
+managed__Microsoft_AspNetCore_Components_WebAssembly__Microsoft_AspNetCore_Components_WebAssembly_Services_DefaultWebAssemblyJSRuntime_BeginInvokeDotNet @ managed__Microsoft_AspNetCore_Components_WebAssembly__Microsoft_AspNetCore_Components_WebAssembly_Services_DefaultWebAssemblyJSRuntime_BeginInvokeDotNet:19
+beginInvokeDotNetFromJS @ blazor.webassembly.js:1
+b @ blazor.webassembly.js:1
+invokeMethodAsync @ blazor.webassembly.js:1
+(anonymous) @ blazor.webassembly.js:1
+invokeWhenHeapUnlocked @ blazor.webassembly.js:1
+S @ blazor.webassembly.js:1
+C @ blazor.webassembly.js:1
+dispatchGlobalEventToAllElements @ blazor.webassembly.js:1
+onGlobalEvent @ blazor.webassembly.js:1
+```
+
+In order to get symbols, the user should:
+
+1. Install the `wasm-tools` workload using `dotnet workload install wasm-tools`
+2. Set these additional properties in their `.csproj` file:
+
+   ```xml
+     <!-- Builds a dotnet.wasm with debug symbols preserved -->
+     <PropertyGroup>
+       <WasmBuildNative>true</WasmBuildNative>
+       <WasmNativeStrip>false</WasmNativeStrip>
+     </PropertyGroup>
+   ```
+
+3. Delete the `bin` and `obj` folders, re-build the project and run it again.
+
+Now clicking on the `Crash` button will produce a stack trace with symbols:
+
+```console
+dotnet.wasm:0x224878 Uncaught (in promise) RuntimeError: memory access out of bounds
+    at dlfree (dotnet.wasm:0x224878)
+    at SystemNative_Free (dotnet.wasm:0x20f0e2)
+    at do_icall (dotnet.wasm:0x190f9)
+    at do_icall_wrapper (dotnet.wasm:0x18429)
+    at interp_exec_method (dotnet.wasm:0xa56c)
+    at interp_runtime_invoke (dotnet.wasm:0x943a)
+    at mono_jit_runtime_invoke (dotnet.wasm:0x1dec32)
+    at do_runtime_invoke (dotnet.wasm:0x95fca)
+    at mono_runtime_invoke_checked (dotnet.wasm:0x95f57)
+    at mono_runtime_try_invoke_array (dotnet.wasm:0x9a87e)
+$dlfree @ dotnet.wasm:0x224878
+$SystemNative_Free @ dotnet.wasm:0x20f0e2
+$do_icall @ dotnet.wasm:0x190f9
+$do_icall_wrapper @ dotnet.wasm:0x18429
+$interp_exec_method @ dotnet.wasm:0xa56c
+$interp_runtime_invoke @ dotnet.wasm:0x943a
+$mono_jit_runtime_invoke @ dotnet.wasm:0x1dec32
+$do_runtime_invoke @ dotnet.wasm:0x95fca
+$mono_runtime_invoke_checked @ dotnet.wasm:0x95f57
+$mono_runtime_try_invoke_array @ dotnet.wasm:0x9a87e
+$mono_runtime_invoke_array_checked @ dotnet.wasm:0x9af17
+$ves_icall_InternalInvoke @ dotnet.wasm:0x702ed
+$ves_icall_InternalInvoke_raw @ dotnet.wasm:0x7777f
+$do_icall @ dotnet.wasm:0x191c5
+$do_icall_wrapper @ dotnet.wasm:0x18429
+$interp_exec_method @ dotnet.wasm:0xa56c
+$interp_runtime_invoke @ dotnet.wasm:0x943a
+$mono_jit_runtime_invoke @ dotnet.wasm:0x1dec32
+$do_runtime_invoke @ dotnet.wasm:0x95fca
+$mono_runtime_try_invoke @ dotnet.wasm:0x966fe
+$mono_runtime_invoke @ dotnet.wasm:0x98982
+$mono_wasm_invoke_method @ dotnet.wasm:0x227de2
+Module._mono_wasm_invoke_method @ dotnet..y6ggkhlo8e.js:9927
+managed__Microsoft_AspNetCore_Components_WebAssembly__Microsoft_AspNetCore_Components_WebAssembly_Services_DefaultWebAssemblyJSRuntime_BeginInvokeDotNet @ managed__Microsoft_AspNetCore_Components_WebAssembly__Microsoft_AspNetCore_Components_WebAssembly_Services_DefaultWebAssemblyJSRuntime_BeginInvokeDotNet:19
+beginInvokeDotNetFromJS @ blazor.webassembly.js:1
+b @ blazor.webassembly.js:1
+invokeMethodAsync @ blazor.webassembly.js:1
+(anonymous) @ blazor.webassembly.js:1
+invokeWhenHeapUnlocked @ blazor.webassembly.js:1
+S @ blazor.webassembly.js:1
+C @ blazor.webassembly.js:1
+dispatchGlobalEventToAllElements @ blazor.webassembly.js:1
+onGlobalEvent @ blazor.webassembly.js:1
+```

From 6233735c37b1af9c182c28c9d74aeac0104785b8 Mon Sep 17 00:00:00 2001
From: Fred Silberberg <frsilb@microsoft.com>
Date: Thu, 27 Jan 2022 11:34:31 -0800
Subject: [PATCH 117/161] Add attributes for required members (#64287)

* Add attributes for required members

Closes https://github.com/dotnet/runtime/issues/64248.

* Address PR feedback

* Update src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

* Address PR feedback
---
 .../System.Private.CoreLib.Shared.projitems    |  2 ++
 .../SetsRequiredMembersAttribute.cs            | 18 ++++++++++++++++++
 .../RequiredMemberAttribute.cs                 | 15 +++++++++++++++
 .../System.Runtime/ref/System.Runtime.cs       | 10 ++++++++++
 .../tests/System.Runtime.Tests.csproj          |  1 +
 .../SetsRequiredMembersAttributeTests.cs       | 16 ++++++++++++++++
 .../CompilerServices/AttributesTests.cs        |  6 ++++++
 7 files changed, 68 insertions(+)
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttribute.cs
 create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RequiredMemberAttribute.cs
 create mode 100644 src/libraries/System.Runtime/tests/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttributeTests.cs

diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index b7079c0ea1ff52..6c8c6bcfd3315a 100644
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -261,6 +261,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\CodeAnalysis\RequiresAssemblyFilesAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\CodeAnalysis\RequiresDynamicCodeAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttribute.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\CodeAnalysis\SetsRequiredMembersAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\CodeAnalysis\StringSyntaxAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\CodeAnalysis\SuppressMessageAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttribute.cs" />
@@ -748,6 +749,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\PoolingAsyncValueTaskMethodBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\PoolingAsyncValueTaskMethodBuilderT.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\PreserveBaseOverridesAttribute.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\RequiredMemberAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\RuntimeCompatibilityAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\RuntimeFeature.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\CompilerServices\RuntimeHelpers.cs" />
diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttribute.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttribute.cs
new file mode 100644
index 00000000000000..f776dd576c84e0
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttribute.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Specifies that this constructor sets all required members for the current type, and callers
+    /// do not need to set any required members themselves.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+        sealed class SetsRequiredMembersAttribute : Attribute
+    { }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RequiredMemberAttribute.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RequiredMemberAttribute.cs
new file mode 100644
index 00000000000000..4a17cfc290b2a6
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RequiredMemberAttribute.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>Specifies that a type has required members or that a member is required.</summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+        sealed class RequiredMemberAttribute : Attribute
+    { }
+}
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index 35930e8deffa9f..7e67104fd9d2cd 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -9186,6 +9186,11 @@ public RequiresUnreferencedCodeAttribute(string message) { }
         public string Message { get { throw null; } }
         public string? Url { get { throw null; } set { } }
     }
+    [System.AttributeUsage(System.AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
+    public sealed class SetsRequiredMembersAttribute : System.Attribute
+    {
+        public SetsRequiredMembersAttribute() { }
+    }
     [System.AttributeUsageAttribute(System.AttributeTargets.Parameter | System.AttributeTargets.Field | System.AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
     public sealed partial class StringSyntaxAttribute : System.Attribute
     {
@@ -13206,6 +13211,11 @@ public sealed partial class PreserveBaseOverridesAttribute : System.Attribute
     {
         public PreserveBaseOverridesAttribute() { }
     }
+    [System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Struct | System.AttributeTargets.Field | System.AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+    public sealed class RequiredMemberAttribute : System.Attribute
+    {
+        public RequiredMemberAttribute() { }
+    }
     [System.AttributeUsageAttribute(System.AttributeTargets.Assembly, AllowMultiple=false)]
     public sealed partial class ReferenceAssemblyAttribute : System.Attribute
     {
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj b/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj
index 3ef404493078e0..051fe609d634b0 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj
@@ -165,6 +165,7 @@
     <Compile Include="System\Diagnostics\CodeAnalysis\RequiresAssemblyFilesAttributeTests.cs" />
     <Compile Include="System\Diagnostics\CodeAnalysis\RequiresDynamicCodeAttributeTests.cs" />
     <Compile Include="System\Diagnostics\CodeAnalysis\RequiresUnreferencedCodeAttributeTests.cs" />
+    <Compile Include="System\Diagnostics\CodeAnalysis\SetsRequiredMembersAttributeTests.cs" />
     <Compile Include="System\Diagnostics\CodeAnalysis\UnconditionalSuppressMessageAttributeTests.cs" />
     <Compile Include="System\Diagnostics\StackTraceHiddenAttributeTests.cs" />
     <Compile Include="System\IO\DirectoryNotFoundExceptionTests.cs" />
diff --git a/src/libraries/System.Runtime/tests/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttributeTests.cs b/src/libraries/System.Runtime/tests/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttributeTests.cs
new file mode 100644
index 00000000000000..f4de6a4c9fecee
--- /dev/null
+++ b/src/libraries/System.Runtime/tests/System/Diagnostics/CodeAnalysis/SetsRequiredMembersAttributeTests.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Xunit;
+
+namespace System.Diagnostics.CodeAnalysis.Tests
+{
+    public class SetsRequiredMembersAttributeTests
+    {
+        [Fact]
+        public void TestConstructor()
+        {
+            new SetsRequiredMembersAttribute();
+        }
+    }
+}
diff --git a/src/libraries/System.Runtime/tests/System/Runtime/CompilerServices/AttributesTests.cs b/src/libraries/System.Runtime/tests/System/Runtime/CompilerServices/AttributesTests.cs
index 4e641224dffc42..dbba5a966f7b07 100644
--- a/src/libraries/System.Runtime/tests/System/Runtime/CompilerServices/AttributesTests.cs
+++ b/src/libraries/System.Runtime/tests/System/Runtime/CompilerServices/AttributesTests.cs
@@ -320,5 +320,11 @@ public static void InterpolatedStringHandlerArgumentAttributeTests(string firstP
             Assert.Equal(firstParameterName, attr2.Arguments[0]);
             Assert.Equal("param2", attr2.Arguments[1]);
         }
+
+        [Fact]
+        public static void RequiredMemberAttributeTests()
+        {
+            new RequiredMemberAttribute();
+        }
     }
 }

From 34c3bea813da2fae4e5058446742f0ce317c2c58 Mon Sep 17 00:00:00 2001
From: Andy Ayers <andya@microsoft.com>
Date: Thu, 27 Jan 2022 12:08:31 -0800
Subject: [PATCH 118/161] fix arm64 genInstrWithConstant (#64368)

---
 src/coreclr/jit/codegenarm.cpp   | 2 +-
 src/coreclr/jit/codegenarm64.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/coreclr/jit/codegenarm.cpp b/src/coreclr/jit/codegenarm.cpp
index 9dd13cdc125332..18cb59068bab39 100644
--- a/src/coreclr/jit/codegenarm.cpp
+++ b/src/coreclr/jit/codegenarm.cpp
@@ -82,7 +82,7 @@ bool CodeGen::genInstrWithConstant(
         // generate two or more instructions
 
         // first we load the immediate into tmpReg
-        instGen_Set_Reg_To_Imm(attr, tmpReg, imm);
+        instGen_Set_Reg_To_Imm(EA_PTRSIZE, tmpReg, imm);
 
         // generate the instruction using a three register encoding with the immediate in tmpReg
         GetEmitter()->emitIns_R_R_R(ins, attr, reg1, reg2, tmpReg);
diff --git a/src/coreclr/jit/codegenarm64.cpp b/src/coreclr/jit/codegenarm64.cpp
index abcd70d040f0b9..595e2a232e5415 100644
--- a/src/coreclr/jit/codegenarm64.cpp
+++ b/src/coreclr/jit/codegenarm64.cpp
@@ -120,7 +120,7 @@ bool CodeGen::genInstrWithConstant(instruction ins,
         // generate two or more instructions
 
         // first we load the immediate into tmpReg
-        instGen_Set_Reg_To_Imm(size, tmpReg, imm);
+        instGen_Set_Reg_To_Imm(EA_PTRSIZE, tmpReg, imm);
         regSet.verifyRegUsed(tmpReg);
 
         // when we are in an unwind code region

From 9ff2549cbf26d2b8a74e48d82e9f44683de14734 Mon Sep 17 00:00:00 2001
From: Maoni Stephens <Maoni0@users.noreply.github.com>
Date: Thu, 27 Jan 2022 12:11:11 -0800
Subject: [PATCH 119/161] 2 fixes related to commit/decommit (#64316)

fixed 2 bugs related to commit/decommit -

in committed_size we need to get the committed in free correctly with the region_free_list change.
in decommit_heap_segment_pages_worker we need the right data type for comparing heap_segment_committed with new_committed as the latter could be before the former.
---
 src/coreclr/gc/gc.cpp   | 23 ++++++++++++++---------
 src/coreclr/gc/gcpriv.h |  4 +---
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp
index 3927e97c723b35..c15f926fa756b1 100644
--- a/src/coreclr/gc/gc.cpp
+++ b/src/coreclr/gc/gc.cpp
@@ -2444,8 +2444,6 @@ heap_segment* gc_heap::reserved_free_regions_sip[max_generation];
 
 int         gc_heap::num_sip_regions = 0;
 
-size_t      gc_heap::committed_in_free = 0;
-
 size_t      gc_heap::end_gen0_region_space = 0;
 
 size_t      gc_heap::gen0_pinned_free_space = 0;
@@ -11139,9 +11137,6 @@ heap_segment* gc_heap::get_free_region (int gen_number, size_t size)
 {
     heap_segment* region = 0;
 
-    // TODO: the update to committed_in_free is incorrect - we'd need synchorization 'cause a thread
-    // could be getting a small and another one could be getting a large region at the same time.
-    // This is only used for recording.
     if (gen_number <= max_generation)
     {
         assert (size == 0);
@@ -11543,6 +11538,8 @@ void gc_heap::decommit_heap_segment_pages (heap_segment* seg,
     if (use_large_pages_p)
         return;
     uint8_t*  page_start = align_on_page (heap_segment_allocated(seg));
+    assert (heap_segment_committed (seg) >= page_start);
+
     size_t size = heap_segment_committed (seg) - page_start;
     extra_space = align_on_page (extra_space);
     if (size >= max ((extra_space + 2*OS_PAGE_SIZE), MIN_DECOMMIT_SIZE))
@@ -11563,10 +11560,10 @@ size_t gc_heap::decommit_heap_segment_pages_worker (heap_segment* seg,
 #endif
     assert (!use_large_pages_p);
     uint8_t* page_start = align_on_page (new_committed);
-    size_t size = heap_segment_committed (seg) - page_start;
+    ptrdiff_t size = heap_segment_committed (seg) - page_start;
     if (size > 0)
     {
-        bool decommit_succeeded_p = virtual_decommit (page_start, size, heap_segment_oh (seg), heap_number);
+        bool decommit_succeeded_p = virtual_decommit (page_start, (size_t)size, heap_segment_oh (seg), heap_number);
         if (decommit_succeeded_p)
         {
             dprintf (3, ("Decommitting heap segment [%Ix, %Ix[(%d)",
@@ -13564,7 +13561,6 @@ gc_heap::init_gc_heap (int  h_number)
     sip_seg_maxgen_interval = 3;
     num_condemned_regions = 0;
 #endif //STRESS_REGIONS
-    committed_in_free = 0;
     end_gen0_region_space = 0;
     gen0_pinned_free_space = 0;
     gen0_large_chunk_found = false;
@@ -24370,8 +24366,17 @@ size_t gc_heap::committed_size()
     }
 
 #ifdef USE_REGIONS
+    size_t committed_in_free = 0;
+
+    for (int kind = basic_free_region; kind < count_free_region_kinds; kind++)
+    {
+        committed_in_free += free_regions[kind].get_size_committed_in_free();
+    }
+
+    dprintf (3, ("h%d committed in free %Id", heap_number, committed_in_free));
+
     total_committed += committed_in_free;
-#endif //USE_REGIO
+#endif //USE_REGIONS
 
     return total_committed;
 }
diff --git a/src/coreclr/gc/gcpriv.h b/src/coreclr/gc/gcpriv.h
index baa0272db1368d..567e7c1bd69caf 100644
--- a/src/coreclr/gc/gcpriv.h
+++ b/src/coreclr/gc/gcpriv.h
@@ -1175,6 +1175,7 @@ class region_free_list
     heap_segment* unlink_region_front();
     heap_segment* unlink_smallest_region (size_t size);
     size_t get_num_free_regions();
+    size_t get_size_committed_in_free() { return size_committed_in_free_regions; }
     size_t get_size_free_regions() { return size_free_regions; }
     heap_segment* get_first_free_region() { return head_free_region; }
     static void unlink_region (heap_segment* region);
@@ -3594,9 +3595,6 @@ class gc_heap
     PER_HEAP
     int num_sip_regions;
 
-    PER_HEAP
-    size_t committed_in_free;
-
     PER_HEAP
     // After plan we calculate this as the planned end gen0 space;
     // but if we end up sweeping, we recalculate it at the end of

From 2feeccf1f8286aab52fe1880670b93d7a8f58061 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Fri, 28 Jan 2022 05:22:55 +0900
Subject: [PATCH 120/161] Build ILCompiler NuGet packages (#63212)

This is using the same strategy we used to build the package in the runtimelab repo.
---
 eng/Subsets.props                             |  1 +
 .../Directory.Build.props                     | 10 +++++++
 .../ILCompilerRIDs.props                      | 13 ++++++++++
 .../Microsoft.DotNet.ILCompiler.pkgproj       | 26 +++++++++++++++++++
 .../pkg/projects/nativeaot-packages.proj      | 14 ++++++++++
 5 files changed, 64 insertions(+)
 create mode 100644 src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Directory.Build.props
 create mode 100644 src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/ILCompilerRIDs.props
 create mode 100644 src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Microsoft.DotNet.ILCompiler.pkgproj
 create mode 100644 src/installer/pkg/projects/nativeaot-packages.proj

diff --git a/eng/Subsets.props b/eng/Subsets.props
index fbe6f9712686ed..4fc54cfd823d15 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -363,6 +363,7 @@
         <SharedFrameworkProjectToBuild Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)'" Include="$(InstallerProjectRoot)pkg\sfx\installers\dotnet-runtime-deps\*.proj" />
         <SharedFrameworkProjectToBuild Condition="'$(RuntimeFlavor)' == '$(PrimaryRuntimeFlavor)'" Include="$(InstallerProjectRoot)pkg\archives\dotnet-nethost.proj" />
         <SharedFrameworkProjectToBuild Condition="'$(MonoCrossAOTTargetOS)' != ''" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\monocrossaot.sfxproj" Pack="true" />
+        <ProjectToBuild Condition="'$(NativeAotSupported)' == 'true' and '$(RuntimeFlavor)' != 'Mono'" Include="$(InstallerProjectRoot)\pkg\projects\nativeaot-packages.proj" Category="packs" />
       </ItemGroup>
       <ItemGroup>
         <SharedFrameworkProjectToBuild Condition="'$(BuildMonoAOTCrossCompilerOnly)' != 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Runtime.sfxproj" />
diff --git a/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Directory.Build.props b/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Directory.Build.props
new file mode 100644
index 00000000000000..1f343d09fe1053
--- /dev/null
+++ b/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Directory.Build.props
@@ -0,0 +1,10 @@
+<Project>
+
+  <!-- Must set this before importing the file below -->
+  <PropertyGroup>
+    <RIDPropsFile>$(MSBuildThisFileDirectory)ILCompilerRIDs.props</RIDPropsFile>
+  </PropertyGroup>
+
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props, $(MSBuildThisFileDirectory)..))" />
+
+</Project>
diff --git a/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/ILCompilerRIDs.props b/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/ILCompilerRIDs.props
new file mode 100644
index 00000000000000..70e13f311b74a7
--- /dev/null
+++ b/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/ILCompilerRIDs.props
@@ -0,0 +1,13 @@
+<Project>
+  <!-- The list of RIDs supported by ILCompiler -->
+  <ItemGroup>
+    <OfficialBuildRID Include="linux-arm" Platform="arm" />
+    <OfficialBuildRID Include="linux-musl-arm64" Platform="arm64" />
+    <OfficialBuildRID Include="linux-arm64" Platform="arm64" />
+    <OfficialBuildRID Include="linux-musl-x64" Platform="x64" />
+    <OfficialBuildRID Include="linux-x64" Platform="x64" />
+    <OfficialBuildRID Include="osx-x64" Platform="x64" />
+    <OfficialBuildRID Include="win-arm64" Platform="arm64" />
+    <OfficialBuildRID Include="win-x64" Platform="x64" />
+  </ItemGroup>
+</Project>
diff --git a/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Microsoft.DotNet.ILCompiler.pkgproj b/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Microsoft.DotNet.ILCompiler.pkgproj
new file mode 100644
index 00000000000000..65fd54d7bf3fb6
--- /dev/null
+++ b/src/installer/pkg/projects/Microsoft.DotNet.ILCompiler/Microsoft.DotNet.ILCompiler.pkgproj
@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <GeneratePackage>true</GeneratePackage>
+    <IncludeSymbolsInPackage>true</IncludeSymbolsInPackage>
+    <PackageDescription>Provides a native AOT compiler and runtime for .NET</PackageDescription>
+  </PropertyGroup>
+
+  <Target Name="GetIlcCompilerFiles"
+          DependsOnTargets="ResolveLibrariesFromLocalBuild"
+          BeforeTargets="GetPackageFiles">
+
+    <ItemGroup Condition="'$(PackageTargetRuntime)' != ''">
+      <File Include="@(LibrariesRuntimeFiles)" TargetPath="framework" />
+      <File Include="$(CoreCLRILCompilerDir)*" TargetPath="tools" />
+      <File Include="$(CoreCLRAotSdkDir)*" TargetPath="sdk" />
+      <File Include="$(MibcOptimizationDataDir)/$(TargetOS)/$(TargetArchitecture)/**/*.mibc" TargetPath="mibc" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <File Include="$(CoreCLRBuildIntegrationDir)*" TargetPath="build" />
+      <File Include="$(CoreCLRILCompilerDir)netstandard\*" TargetPath="tools/netstandard" />
+    </ItemGroup>
+  </Target>
+
+</Project>
diff --git a/src/installer/pkg/projects/nativeaot-packages.proj b/src/installer/pkg/projects/nativeaot-packages.proj
new file mode 100644
index 00000000000000..10ab1d60c56fa5
--- /dev/null
+++ b/src/installer/pkg/projects/nativeaot-packages.proj
@@ -0,0 +1,14 @@
+<Project>
+  <Import Sdk="Microsoft.Build.Traversal" Project="Sdk.props" />
+
+  <ItemGroup>
+    <Project Include="Microsoft.DotNet.ILCompiler\Microsoft.DotNet.ILCompiler.pkgproj" />
+    <ProjectReference Include="@(Project)" />
+    <ProjectReference Include="@(Project)" AdditionalProperties="PackageTargetRuntime=$(OutputRid)" />
+  </ItemGroup>
+
+  <Import Sdk="Microsoft.Build.Traversal" Project="Sdk.targets" />
+
+  <!-- Ordering matters! Overwriting the Pack target which should just invoke Build. -->
+  <Target Name="Pack" DependsOnTargets="Build" />
+</Project>

From d0165693994c2f83265f7dbf757d4f437d4bb073 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aleksey=20Kliger=20=28=CE=BBgeek=29?= <alklig@microsoft.com>
Date: Thu, 27 Jan 2022 15:25:45 -0500
Subject: [PATCH 121/161] [mono] Re-enable tests that call MakeGenericType with
 non-RuntimeType arguments (#64344)

* [mono] Re-enable tests that call MakeGenericType with non-RuntimeType arguments

   Fixes https://github.com/dotnet/runtime/issues/32743

   The actual fix was in https://github.com/dotnet/runtime/pull/58014

* [wasm] Disable some logging generator tests

`Microsoft.Extensions.Logging.Generators.Tests.LoggerMessageGeneratorEmitterTests.*`
`Microsoft.Extensions.Logging.Generators.Tests.LoggerMessageGeneratorParserTests.*`

.. failing like:

```
[18:09:38] fail: [FAIL] Microsoft.Extensions.Logging.Generators.Tests.LoggerMessageGeneratorParserTests.NotPartial
[18:09:38] info: System.ArgumentException : Empty path name is not legal. (Parameter 'path')
[18:09:38] info:    at System.IO.Strategies.FileStreamHelpers.ValidateArguments(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options, Int64 preallocationSize)
[18:09:38] info:    at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options, Int64 preallocationSize)
[18:09:38] info:    at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options)
[18:09:38] info:    at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, Boolean useAsync)
[18:09:38] info:    at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share)
[18:09:38] info:    at Roslyn.Utilities.StandardFileSystem.OpenFile(String filePath, FileMode mode, FileAccess access, FileShare share)
[18:09:38] info:    at Roslyn.Utilities.CommonCompilerFileSystemExtensions.OpenFileWithNormalizedException(ICommonCompilerFileSystem fileSystem, String filePath, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
[18:09:38] info:    at Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(String path, MetadataReferenceProperties properties, DocumentationProvider documentation)
[18:09:38] info:    at SourceGenerators.Tests.RoslynTestUtils.CreateTestProject(IEnumerable`1 references, Boolean includeBaseReferences)
[18:09:38] info:    at SourceGenerators.Tests.RoslynTestUtils.RunGenerator(ISourceGenerator generator, IEnumerable`1 references, IEnumerable`1 sources, Boolean includeBaseReferences, CancellationToken cancellationToken)
[18:09:38] info:    at Microsoft.Extensions.Logging.Generators.Tests.LoggerMessageGeneratorParserTests.RunGenerator(String code, Boolean wrap, Boolean inNamespace, Boolean includeBaseReferences, Boolean includeLoggingReferences, CancellationToken cancellationToken)
[18:09:38] info:    at Microsoft.Extensions.Logging.Generators.Tests.LoggerMessageGeneratorParserTests.NotPartial()
[18:09:38] info: --- End of stack trace from previous location ---
```

.. due to https://github.com/dotnet/runtime/issues/52062 .

* Disable RegistrationBuilderTests that require ref emit on platforms that don't support it

Co-authored-by: Ankit Jain <radical@gmail.com>
---
 .../LoggerMessageGeneratedCodeTests.cs            |  1 -
 .../LoggerMessageGeneratorEmitterTests.cs         |  2 +-
 .../LoggerMessageGeneratorParserTests.cs          |  2 +-
 .../Registration/RegistrationBuilderTests.cs      | 15 +++++----------
 4 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs
index eced8b527b1200..eda529fade4ef1 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratedCodeTests.cs
@@ -8,7 +8,6 @@
 
 namespace Microsoft.Extensions.Logging.Generators.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
     public class LoggerMessageGeneratedCodeTests
     {
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
index 0cd1371b9b213d..3b7079e9b83986 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.Extensions.Logging.Generators.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/52062", TestPlatforms.Browser)]
     public class LoggerMessageGeneratorEmitterTests
     {
         [Fact]
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs
index 9edd953f997dfc..4697e5603cd0f5 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorParserTests.cs
@@ -13,7 +13,7 @@
 
 namespace Microsoft.Extensions.Logging.Generators.Tests
 {
-    [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/52062", TestPlatforms.Browser)]
     public class LoggerMessageGeneratorParserTests
     {
         [Fact]
diff --git a/src/libraries/System.ComponentModel.Composition.Registration/tests/System/ComponentModel/Composition/Registration/RegistrationBuilderTests.cs b/src/libraries/System.ComponentModel.Composition.Registration/tests/System/ComponentModel/Composition/Registration/RegistrationBuilderTests.cs
index f095d38c045462..ab5b9a5ac00760 100644
--- a/src/libraries/System.ComponentModel.Composition.Registration/tests/System/ComponentModel/Composition/Registration/RegistrationBuilderTests.cs
+++ b/src/libraries/System.ComponentModel.Composition.Registration/tests/System/ComponentModel/Composition/Registration/RegistrationBuilderTests.cs
@@ -44,8 +44,7 @@ public DiscoveredCatalog()
                 : base("") { }
         }
 
-        [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
         public void ShouldSucceed()
         {
             var rb = new RegistrationBuilder();
@@ -174,8 +173,7 @@ private interface IGenericInterface<T> { }
         [Export(typeof(IGenericInterface<>))]
         private class ClassExportingInterface<T> : IGenericInterface<T> { }
 
-        [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
         public void GenericInterfaceExportInRegistrationBuilder()
         {
             CompositionContainer container = CreateRegistrationBuilderContainer(typeof(ClassExportingInterface<>));
@@ -188,8 +186,7 @@ private class GenericBaseClass<T> { }
         [Export(typeof(GenericBaseClass<>))]
         private class ClassExportingBaseClass<T> : GenericBaseClass<T> { }
 
-        [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
         public void GenericBaseClassExportInRegistrationBuilder()
         {
             CompositionContainer container = CreateRegistrationBuilderContainer(typeof(ClassExportingBaseClass<>));
@@ -211,8 +208,7 @@ public void GenericExportInRegistrationBuilder()
         [Export(typeof(ExplicitGenericClass<>))]
         private class ExplicitGenericClass<T> { }
 
-        [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
         public void ExplicitGenericExportInRegistrationBuilder()
         {
             CompositionContainer container = CreateRegistrationBuilderContainer(typeof(ExplicitGenericClass<>));
@@ -223,8 +219,7 @@ public void ExplicitGenericExportInRegistrationBuilder()
         [Export(typeof(ExplicitGenericClass<,>))]
         private class ExplicitGenericClass<T, U> { }
 
-        [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/32743", TestRuntimes.Mono)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
         public void ExplicitGenericArity2ExportInRegistrationBuilder()
         {
             CompositionContainer container = CreateRegistrationBuilderContainer(typeof(ExplicitGenericClass<,>));

From 7e0a2f029892b2b287ccbb8af6d94c3be8116479 Mon Sep 17 00:00:00 2001
From: Dan Moseley <danmose@microsoft.com>
Date: Thu, 27 Jan 2022 14:59:03 -0700
Subject: [PATCH 122/161] Disable ipv6 lookup tests when needed (#64313)

* Disable ipv6 lookup tests when needed

* comment

* nit
---
 .../tests/PalTests/NameResolutionPalTests.cs  | 33 +++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs b/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs
index 5ae74af0bd538c..d2c0b1fc229c65 100644
--- a/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs
+++ b/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs
@@ -1,7 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.Win32;
 using System.IO;
+using System.Linq;
 using System.Net.Sockets;
 using System.Runtime.InteropServices;
 using System.Threading;
@@ -15,6 +17,33 @@ public class NameResolutionPalTests
     {
         private readonly ITestOutputHelper _output;
 
+        private static Lazy<bool> s_ipv6LocalHostNameLookupBrokenByNrpRule = new Lazy<bool>(() =>
+        {
+            // On some machines using Microsoft corporate VPN, something sometimes installs an DNS Name Resolution Policy rule
+            // that breaks reverse lookup of ipv6 localhost names.
+            if (PlatformDetection.IsWindows)
+            {
+                // Equivalent of `Get-DnsClientNrptRule -Name .ip6.arpa`
+                using RegistryKey? key = Registry.LocalMachine.OpenSubKey(@"SYSTEM\CurrentControlSet\Services\Dnscache\Parameters\DnsPolicyConfig");
+                if (key != null)
+                {
+                    // Also filtering out anything not written by MSFTVPN
+                    foreach (string name in key.GetSubKeyNames().Where(name => name.Contains("MSFTVPN")))
+                    {
+                        using RegistryKey? key2 = key.OpenSubKey(name);
+                        if (key2 != null && key2.GetValue("Name") is string[] values && values.Length == 1 && values[0] == ".ip6.arpa")
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        });
+
+        private static bool Ipv6LocalHostNameLookupNotBrokenByNrpRule => !s_ipv6LocalHostNameLookupBrokenByNrpRule.Value;
+
         public NameResolutionPalTests(ITestOutputHelper output)
         {
             _output = output;
@@ -131,7 +160,7 @@ public void TryGetNameInfo_LocalHost_IPv4()
             Assert.NotNull(name);
         }
 
-        [Fact]
+        [ConditionalFact(nameof(Ipv6LocalHostNameLookupNotBrokenByNrpRule))]
         public void TryGetNameInfo_LocalHost_IPv6()
         {
             SocketError error;
@@ -230,7 +259,7 @@ public void TryGetNameInfo_LocalHost_IPv4_TryGetAddrInfo(bool justAddresses)
             Assert.NotNull(addresses);
         }
 
-        [Theory]
+        [ConditionalTheory(nameof(Ipv6LocalHostNameLookupNotBrokenByNrpRule))]
         [InlineData(false)]
         [InlineData(true)]
         public void TryGetNameInfo_LocalHost_IPv6_TryGetAddrInfo(bool justAddresses)

From 10df82910227e382c447f8157e8a307795f34b94 Mon Sep 17 00:00:00 2001
From: Jeremy Barton <jbarton@microsoft.com>
Date: Thu, 27 Jan 2022 14:25:02 -0800
Subject: [PATCH 123/161] Temporarily disable EC file import tests (#64397)

---
 .../AlgorithmImplementations/ECDiffieHellman/ECDhKeyFileTests.cs | 1 +
 .../AlgorithmImplementations/ECDsa/ECDsaKeyFileTests.cs          | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDhKeyFileTests.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDhKeyFileTests.cs
index af64f2fc031eb1..ff6f0c99d193ce 100644
--- a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDhKeyFileTests.cs
+++ b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDhKeyFileTests.cs
@@ -7,6 +7,7 @@
 namespace System.Security.Cryptography.EcDiffieHellman.Tests
 {
     [SkipOnPlatform(TestPlatforms.Browser, "Not supported on Browser")]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/64389", TestPlatforms.Windows)]
     public class ECDhKeyFileTests : ECKeyFileTests<ECDiffieHellman>
     {
         protected override ECDiffieHellman CreateKey() => ECDiffieHellmanFactory.Create();
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaKeyFileTests.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaKeyFileTests.cs
index 35bed6e7247855..51bb3d34182aa4 100644
--- a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaKeyFileTests.cs
+++ b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaKeyFileTests.cs
@@ -7,6 +7,7 @@
 namespace System.Security.Cryptography.EcDsa.Tests
 {
     [SkipOnPlatform(TestPlatforms.Browser, "Not supported on Browser")]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/64389", TestPlatforms.Windows)]
     public class ECDsaKeyFileTests : ECKeyFileTests<ECDsa>
     {
         protected override ECDsa CreateKey() => ECDsaFactory.Create();

From 4c09cb9601efc8e17dbba78f0a5e6f3541fa0122 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexander=20K=C3=B6plinger?= <alex.koeplinger@outlook.com>
Date: Thu, 27 Jan 2022 23:31:23 +0100
Subject: [PATCH 124/161] Fix Xamarin assembly names in HttpClientHandler
 (#64385)

Update to match the new names from https://github.com/xamarin/xamarin-macios/pull/13847
---
 ...ttpClientHandler.AnyMobile.InvokeNativeHandler.cs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.InvokeNativeHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.InvokeNativeHandler.cs
index 724e00b571556f..d14bbbf2799cfa 100644
--- a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.InvokeNativeHandler.cs
+++ b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.InvokeNativeHandler.cs
@@ -21,16 +21,16 @@ public partial class HttpClientHandler : HttpMessageHandler
         private const string GetHttpMessageHandlerType = "Android.Runtime.AndroidEnvironment, Mono.Android";
 #elif TARGET_IOS
         private const string NativeHandlerType = "System.Net.Http.NSUrlSessionHandler";
-        private const string AssemblyName = "Xamarin.iOS";
-        private const string GetHttpMessageHandlerType = "ObjCRuntime.RuntimeOptions, Xamarin.iOS";
+        private const string AssemblyName = "Microsoft.iOS";
+        private const string GetHttpMessageHandlerType = "ObjCRuntime.RuntimeOptions, Microsoft.iOS";
 #elif TARGET_MACCATALYST
         private const string NativeHandlerType = "System.Net.Http.NSUrlSessionHandler";
-        private const string AssemblyName = "Xamarin.MacCatalyst";
-        private const string GetHttpMessageHandlerType = "ObjCRuntime.RuntimeOptions, Xamarin.MacCatalyst";
+        private const string AssemblyName = "Microsoft.MacCatalyst";
+        private const string GetHttpMessageHandlerType = "ObjCRuntime.RuntimeOptions, Microsoft.MacCatalyst";
 #elif TARGET_TVOS
         private const string NativeHandlerType = "System.Net.Http.NSUrlSessionHandler";
-        private const string AssemblyName = "Xamarin.TVOS";
-        private const string GetHttpMessageHandlerType = "ObjCRuntime.RuntimeOptions, Xamarin.TVOS";
+        private const string AssemblyName = "Microsoft.tvOS";
+        private const string GetHttpMessageHandlerType = "ObjCRuntime.RuntimeOptions, Microsoft.tvOS";
 #else
 #error Unknown target
 #endif

From 014b0842d2f6b9e6a8ab5b2b0430313f10bd5cb3 Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Thu, 27 Jan 2022 15:49:03 -0800
Subject: [PATCH 125/161] Align rva fields in reflection emit (#63430)

In support of CreateSpan (#60948), improve alignment for RVA static pre-initialized fields to align memory blocks which may contain long, ulong, or double primitive arrays on 8 byte boundaries.

Mono fix is more involved
- Fix Ref-Emit generated RVA statics
 - Set the HasFieldRVA bit. NOTE: earlier code that attempts to set the bit doesn't actually do that as the FieldRVA bit is in  FieldAttributes.ReservedMask which is masked away in the FieldBuilder constructor
 - Fix the Swizzle lookup. We should not be using the 8 byte swizzle in the final else clause.
- Enhance ref-emitted field to allow for use with CreateSpan
  - Ref-emitted fields should specify a pack size appropriate for minimum alignment of the CreateSpan targetted data
  - Respect the packing_size specified so that RVA static fields generated for CreateSpan can be properly aligned

Fixes #62314
---
 src/coreclr/vm/commodule.cpp                  | 10 +++-
 .../ModuleBuilderDefineInitializedData.cs     | 55 +++++++++++++++++++
 .../Reflection/Emit/FieldBuilder.Mono.cs      |  9 +++
 .../Reflection/Emit/ModuleBuilder.Mono.cs     |  2 +-
 .../Reflection/Emit/TypeBuilder.Mono.cs       |  2 +-
 src/mono/mono/metadata/class-accessors.c      |  4 +-
 src/mono/mono/metadata/class-init.c           |  6 ++
 7 files changed, 82 insertions(+), 6 deletions(-)

diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp
index f19482c2a59f38..0e1b0f9d444a95 100644
--- a/src/coreclr/vm/commodule.cpp
+++ b/src/coreclr/vm/commodule.cpp
@@ -499,14 +499,20 @@ extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle p
     if (pReflectionModule->m_sdataSection == 0)
         IfFailThrow( pGen->GetSectionCreate (".sdata", sdReadWrite, &pReflectionModule->m_sdataSection) );
 
+    // Define the alignment that the rva will be set to. Since the CoreCLR runtime only has hard alignment requirements
+    // up to 8 bytes, the highest alignment we may need is 8 byte alignment. This hard alignment requirement is only needed
+    // by Runtime.Helpers.CreateSpan<T>. Since the previous alignment was 4 bytes before CreateSpan was implemented, if the
+    // data isn't itself of size divisible by 8, just align to 4 to the memory cost of excess alignment.
+    DWORD alignment = (length % 8 == 0) ? 8 : 4;
+
     // Get the size of current .sdata section. This will be the RVA for this field within the section
     DWORD dwRVA = 0;
     IfFailThrow( pGen->GetSectionDataLen(pReflectionModule->m_sdataSection, &dwRVA) );
-    dwRVA = (dwRVA + sizeof(DWORD)-1) & ~(sizeof(DWORD)-1);
+    dwRVA = (dwRVA + alignment-1) & ~(alignment-1);
 
     // allocate the space in .sdata section
     void * pvBlob;
-    IfFailThrow( pGen->GetSectionBlock(pReflectionModule->m_sdataSection, length, sizeof(DWORD), (void**) &pvBlob) );
+    IfFailThrow( pGen->GetSectionBlock(pReflectionModule->m_sdataSection, length, alignment, (void**) &pvBlob) );
 
     // copy over the initialized data if specified
     if (pContent != NULL)
diff --git a/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs b/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs
index 77ecb3b5ad60a6..9ad34ef353bc9b 100644
--- a/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs
+++ b/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Xunit;
+using System.Runtime.InteropServices;
 
 namespace System.Reflection.Emit.Tests
 {
@@ -59,5 +60,59 @@ public void DefineInitializedData_CreateGlobalFunctionsCalled_ThrowsInvalidOpera
             module.CreateGlobalFunctions();
             Assert.Throws<InvalidOperationException>(() => module.DefineInitializedData("MyField2", new byte[] { 1, 0, 1 }, FieldAttributes.Public));
         }
+
+        [Fact]
+        public void DefineInitializedData_EnsureAlignmentIsMinimumNeededForUseOfCreateSpan()
+        {
+            ModuleBuilder module = Helpers.DynamicModule();
+
+            // Create static field data in a variety of orders that requires the runtime to actively apply alignment
+            // RuntimeHelpers.CreateSpan requires data to be naturally aligned within the "PE" file. At this time CreateSpan only
+            // requires alignments up to 8 bytes.
+            FieldBuilder field1Byte = module.DefineInitializedData("Field1Byte", new byte[] { 1 }, FieldAttributes.Public);
+            byte[] field4Byte_1_data = new byte[] { 1, 2, 3, 4 };
+            byte[] field8Byte_1_data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+            byte[] field4Byte_2_data = new byte[] { 5, 6, 7, 8 };
+            byte[] field8Byte_2_data = new byte[] { 9, 10, 11, 12, 13, 14, 15, 16 };
+            FieldBuilder field4Byte_1 = module.DefineInitializedData("Field4Bytes_1", field4Byte_1_data, FieldAttributes.Public);
+            FieldBuilder field8Byte_1 = module.DefineInitializedData("Field8Bytes_1", field8Byte_1_data, FieldAttributes.Public);
+            FieldBuilder field4Byte_2 = module.DefineInitializedData("Field4Bytes_2", field4Byte_2_data, FieldAttributes.Public);
+            FieldBuilder field8Byte_2 = module.DefineInitializedData("Field8Bytes_2", field8Byte_2_data, FieldAttributes.Public);
+            module.CreateGlobalFunctions();
+
+            var checkTypeBuilder = module.DefineType("CheckType", TypeAttributes.Public);
+            CreateLoadAddressMethod("LoadAddress1", field1Byte);
+            CreateLoadAddressMethod("LoadAddress4_1", field4Byte_1);
+            CreateLoadAddressMethod("LoadAddress4_2", field4Byte_2);
+            CreateLoadAddressMethod("LoadAddress8_1", field8Byte_1);
+            CreateLoadAddressMethod("LoadAddress8_2", field8Byte_2);
+
+            var checkType = checkTypeBuilder.CreateType();
+
+            CheckMethod("LoadAddress4_1", 4, field4Byte_1_data);
+            CheckMethod("LoadAddress4_2", 4, field4Byte_2_data);
+            CheckMethod("LoadAddress8_1", 8, field8Byte_1_data);
+            CheckMethod("LoadAddress8_2", 8, field8Byte_2_data);
+
+            void CreateLoadAddressMethod(string name, FieldBuilder fieldBuilder)
+            {
+                var loadAddressMethod = checkTypeBuilder.DefineMethod(name, MethodAttributes.Public | MethodAttributes.Static, typeof(IntPtr), null);
+                var methodIL = loadAddressMethod.GetILGenerator();
+                methodIL.Emit(OpCodes.Ldsflda, fieldBuilder);
+                methodIL.Emit(OpCodes.Ret);
+            }
+
+            void CheckMethod(string name, int minAlignmentRequired, byte[] dataToVerify)
+            {
+                var methodToCall = checkType.GetMethod(name);
+                nint address = (nint)methodToCall.Invoke(null, null);
+
+                for (int i = 0; i < dataToVerify.Length; i++)
+                {
+                    Assert.Equal(dataToVerify[i], Marshal.ReadByte(address + (nint)i));
+                }
+                Assert.Equal(name + "_0" + "_" + address.ToString(), name + "_" + (address % minAlignmentRequired).ToString() + "_" + address.ToString());
+            }
+        }
     }
 }
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.Mono.cs
index 4d63c64bdb1233..8d4d278b65c1d1 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.Mono.cs
@@ -149,9 +149,18 @@ internal override int GetFieldOffset()
 
         internal void SetRVAData(byte[] data)
         {
+            attrs = attrs | FieldAttributes.HasFieldRVA;
             rva_data = (byte[])data.Clone();
         }
 
+        internal static PackingSize RVADataPackingSize(int size)
+        {
+            if ((size % 8) == 0) return PackingSize.Size8;
+            if ((size % 4) == 0) return PackingSize.Size4;
+            if ((size % 2) == 0) return PackingSize.Size2;
+            return PackingSize.Size1;
+        }
+
         public void SetConstant(object? defaultValue)
         {
             RejectIfCreated();
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs
index 66816f9ce5bbfe..1095954e87b413 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs
@@ -165,7 +165,7 @@ private FieldBuilder DefineDataImpl(string name, int size, FieldAttributes attri
             {
                 TypeBuilder tb = DefineType(typeName,
                     TypeAttributes.Public | TypeAttributes.ExplicitLayout | TypeAttributes.Sealed,
-                                             typeof(ValueType), null, PackingSize.Size1, size);
+                                             typeof(ValueType), null, FieldBuilder.RVADataPackingSize(size), size);
                 tb.CreateType();
                 datablobtype = tb;
             }
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
index 1209f517736a40..e29d47602e84e2 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
@@ -1608,7 +1608,7 @@ public FieldBuilder DefineUninitializedData(string name, int size, FieldAttribut
             {
                 TypeBuilder tb = DefineNestedType(typeName,
                     TypeAttributes.NestedPrivate | TypeAttributes.ExplicitLayout | TypeAttributes.Sealed,
-                                                   typeof(ValueType), null, PackingSize.Size1, size);
+                                                   typeof(ValueType), null, FieldBuilder.RVADataPackingSize(size), size);
                 tb.CreateType();
                 datablobtype = tb;
             }
diff --git a/src/mono/mono/metadata/class-accessors.c b/src/mono/mono/metadata/class-accessors.c
index 9042a0ebe5b8d3..457292de55074c 100644
--- a/src/mono/mono/metadata/class-accessors.c
+++ b/src/mono/mono/metadata/class-accessors.c
@@ -396,7 +396,7 @@ mono_class_get_field_def_values_with_swizzle (MonoClass *klass, int swizzle)
 		dataKind = PROP_FIELD_DEF_VALUES_2BYTESWIZZLE;
 	else if (swizzle == 4)
 		dataKind = PROP_FIELD_DEF_VALUES_4BYTESWIZZLE;
-	else
+	else if (swizzle == 8)
 		dataKind = PROP_FIELD_DEF_VALUES_8BYTESWIZZLE;
 	return (MonoFieldDefaultValue*)get_pointer_property (klass, dataKind);
 }
@@ -416,7 +416,7 @@ mono_class_set_field_def_values_with_swizzle (MonoClass *klass, MonoFieldDefault
 		dataKind = PROP_FIELD_DEF_VALUES_2BYTESWIZZLE;
 	else if (swizzle == 4)
 		dataKind = PROP_FIELD_DEF_VALUES_4BYTESWIZZLE;
-	else
+	else if (swizzle == 8)
 		dataKind = PROP_FIELD_DEF_VALUES_8BYTESWIZZLE;
 	set_pointer_property (klass, dataKind, values);
 }
diff --git a/src/mono/mono/metadata/class-init.c b/src/mono/mono/metadata/class-init.c
index 0d8a74442b4d26..00ab30ffbd76f2 100644
--- a/src/mono/mono/metadata/class-init.c
+++ b/src/mono/mono/metadata/class-init.c
@@ -2017,6 +2017,12 @@ mono_class_layout_fields (MonoClass *klass, int base_instance_size, int packing_
 		min_align = 16;
 	 */
 
+	/* Respect the specified packing size at least to the extent necessary to align double variables.
+	 * This should avoid any GC problems, and will allow packing_size to be respected to support
+	 * CreateSpan<T>
+	 */
+	min_align = MIN (MONO_ABI_ALIGNOF (double), MAX (min_align, packing_size));
+
 	/*
 	 * When we do generic sharing we need to have layout
 	 * information for open generic classes (either with a generic

From d55a1dfa4e39a26a8ea8d161f733c72805f31f7f Mon Sep 17 00:00:00 2001
From: Egor Chesakov <Egor.Chesakov@microsoft.com>
Date: Thu, 27 Jan 2022 16:18:51 -0800
Subject: [PATCH 126/161] [JIT] Use byteCount when deciding what instruction
 sequence to use in genCodeForCpBlkUnroll (#64315)

* Add regression test for https://github.com/dotnet/runtime/issues/64125

* Don't base decision whether to use ldp/stp or ldr/str for CopyBlock based on a distance between dstOffsetAligned and endDstOffset.
The value can increase when dstOffset is updated and can lead to an un-encodable ldp instruction offset if before we were validating ldr/str path in src/coreclr/jit/codegenarmarch.cpp

* Update tests per feedback

* Try disabling the test for wasm and monointerpreter
---
 src/coreclr/jit/codegenarmarch.cpp            |    2 +-
 .../JitBlue/Runtime_64125/Runtime_64125.cs    | 9215 +++++++++++++++++
 .../Runtime_64125/Runtime_64125.csproj        |   11 +
 .../JitBlue/Runtime_64125/Runtime_64125.tt    |  113 +
 src/tests/issues.targets                      |    6 +
 5 files changed, 9346 insertions(+), 1 deletion(-)
 create mode 100644 src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.cs
 create mode 100644 src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.csproj
 create mode 100644 src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.tt

diff --git a/src/coreclr/jit/codegenarmarch.cpp b/src/coreclr/jit/codegenarmarch.cpp
index 66ecbac761cb5e..24c57d110b7bab 100644
--- a/src/coreclr/jit/codegenarmarch.cpp
+++ b/src/coreclr/jit/codegenarmarch.cpp
@@ -2416,7 +2416,7 @@ class CopyBlockUnrollHelper
 
         const int dstOffsetAligned = AlignUp((UINT)dstOffset, storePairRegsAlignment);
 
-        if (endDstOffset - dstOffsetAligned >= storePairRegsWritesBytes)
+        if (byteCount >= (unsigned)storePairRegsWritesBytes)
         {
             const int dstBytesToAlign = dstOffsetAligned - dstOffset;
 
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.cs b/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.cs
new file mode 100644
index 00000000000000..c12db7ffb3b9a6
--- /dev/null
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.cs
@@ -0,0 +1,9215 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Runtime_64125.cs is AUTOGENERATED. DO NOT MODIFY the file manually.
+// Instead use the following command to generate the .cs file from .tt file.
+//   "%DevEnvDir%\TextTransform.exe" Runtime_64125.tt
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Runtime_64125
+{
+    [StructLayout(LayoutKind.Explicit, Size=1)]
+    struct Struct1Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=2)]
+    struct Struct2Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=3)]
+    struct Struct3Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=4)]
+    struct Struct4Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=7)]
+    struct Struct7Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=8)]
+    struct Struct8Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=15)]
+    struct Struct15Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=16)]
+    struct Struct16Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=31)]
+    struct Struct31Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=32)]
+    struct Struct32Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=63)]
+    struct Struct63Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=64)]
+    struct Struct64Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=127)]
+    struct Struct127Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=128)]
+    struct Struct128Bytes
+    {
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size=65648)]
+    struct AnyOffset
+    {
+        [FieldOffset(252)]
+        public byte fieldAtOffset252;
+        [FieldOffset(255)]
+        public byte fieldAtOffset255;
+        [FieldOffset(504)]
+        public byte fieldAtOffset504;
+        [FieldOffset(1008)]
+        public byte fieldAtOffset1008;
+        [FieldOffset(4095)]
+        public byte fieldAtOffset4095;
+        [FieldOffset(8190)]
+        public byte fieldAtOffset8190;
+        [FieldOffset(16380)]
+        public byte fieldAtOffset16380;
+        [FieldOffset(32760)]
+        public byte fieldAtOffset32760;
+        [FieldOffset(65520)]
+        public byte fieldAtOffset65520;
+    }
+
+    class AnyLocation
+    {
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset252 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset255 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset504 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset1008 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset4095 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset8190 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset16380 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset32760 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy1BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct1Bytes*)&dst->fieldAtOffset65520 = *(Struct1Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset252 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset255 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset504 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset1008 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset4095 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset8190 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset16380 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset32760 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy2BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct2Bytes*)&dst->fieldAtOffset65520 = *(Struct2Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset252 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset255 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset504 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset1008 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset4095 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset8190 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset16380 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset32760 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy3BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct3Bytes*)&dst->fieldAtOffset65520 = *(Struct3Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset252 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset255 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset504 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset1008 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset4095 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset8190 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset16380 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset32760 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy4BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct4Bytes*)&dst->fieldAtOffset65520 = *(Struct4Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset252 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset255 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset504 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset1008 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset4095 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset8190 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset16380 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset32760 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy7BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct7Bytes*)&dst->fieldAtOffset65520 = *(Struct7Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset252 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset255 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset504 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset1008 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset4095 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset8190 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset16380 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset32760 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy8BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct8Bytes*)&dst->fieldAtOffset65520 = *(Struct8Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset252 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset255 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset504 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset1008 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset4095 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset8190 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset16380 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset32760 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy15BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct15Bytes*)&dst->fieldAtOffset65520 = *(Struct15Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset252 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset255 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset504 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset1008 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset4095 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset8190 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset16380 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset32760 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy16BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct16Bytes*)&dst->fieldAtOffset65520 = *(Struct16Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset252 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset255 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset504 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset1008 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset4095 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset8190 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset16380 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset32760 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy31BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct31Bytes*)&dst->fieldAtOffset65520 = *(Struct31Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset252 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset255 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset504 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset1008 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset4095 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset8190 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset16380 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset32760 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy32BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct32Bytes*)&dst->fieldAtOffset65520 = *(Struct32Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset252 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset255 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset504 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset1008 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset4095 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset8190 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset16380 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset32760 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy63BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct63Bytes*)&dst->fieldAtOffset65520 = *(Struct63Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset252 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset255 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset504 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset1008 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset4095 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset8190 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset16380 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset32760 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy64BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct64Bytes*)&dst->fieldAtOffset65520 = *(Struct64Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset252 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset255 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset504 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset1008 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset4095 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset8190 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset16380 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset32760 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy127BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct127Bytes*)&dst->fieldAtOffset65520 = *(Struct127Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset252ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset252;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset255ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset255;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset504ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset504;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset1008ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset1008;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset4095ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset4095;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset8190ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset8190;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset16380ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset16380;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset32760ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset32760;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset252(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset252 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset255(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset255 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset504(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset504 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset1008(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset1008 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset4095(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset4095 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset8190(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset8190 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset16380(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset16380 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset32760(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset32760 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy128BytesFromLocationAtOffset65520ToLocationAtOffset65520(AnyOffset* dst, AnyOffset* src)
+        {
+            *(Struct128Bytes*)&dst->fieldAtOffset65520 = *(Struct128Bytes*)&src->fieldAtOffset65520;
+        }
+
+    }
+
+    class Program
+    {
+        static unsafe void Init(byte* bytes, int byteCount)
+        {
+            for (int i = 0; i < byteCount; i++)
+            {
+                bytes[i] = TestLibrary.Generator.GetByte();
+            }
+        }
+
+        static unsafe bool MemoryCompare(byte* left, byte* right, int byteCount)
+        {
+            for (int i = 0; i < byteCount; i++)
+            {
+                if (left[i] != right[i]) return false;
+            }
+
+            return true;
+        }
+
+        static unsafe int Main(string[] args)
+        {
+            var anyLocation = new AnyLocation();
+
+            var src = new AnyOffset();
+            var dst = new AnyOffset();
+
+            Init((byte*)&src, sizeof(AnyOffset));
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 1)) return 0;
+            anyLocation.Copy1BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 1)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 2)) return 0;
+            anyLocation.Copy2BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 2)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 3)) return 0;
+            anyLocation.Copy3BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 3)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 4)) return 0;
+            anyLocation.Copy4BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 4)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 7)) return 0;
+            anyLocation.Copy7BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 7)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 8)) return 0;
+            anyLocation.Copy8BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 8)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 15)) return 0;
+            anyLocation.Copy15BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 15)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 16)) return 0;
+            anyLocation.Copy16BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 16)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 31)) return 0;
+            anyLocation.Copy31BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 31)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 32)) return 0;
+            anyLocation.Copy32BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 32)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 63)) return 0;
+            anyLocation.Copy63BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 63)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 64)) return 0;
+            anyLocation.Copy64BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 64)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 127)) return 0;
+            anyLocation.Copy127BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 127)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset252ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset252, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset255ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset255, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset504ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset504, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset1008ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset1008, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset4095ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset4095, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset8190ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset8190, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset16380ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset16380, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset32760ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset32760, &dst.fieldAtOffset65520, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset252(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset252, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset255(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset255, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset504(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset504, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset1008(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset1008, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset4095(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset4095, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset8190(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset8190, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset16380(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset16380, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset32760(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset32760, 128)) return 0;
+            anyLocation.Copy128BytesFromLocationAtOffset65520ToLocationAtOffset65520(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset65520, &dst.fieldAtOffset65520, 128)) return 0;
+
+            return 100;
+        }
+    }
+}
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.csproj b/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.csproj
new file mode 100644
index 00000000000000..8f58ccf6438daa
--- /dev/null
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <Optimize>True</Optimize>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(TestSourceDir)Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
+    <Compile Include="$(MSBuildProjectName).cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.tt b/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.tt
new file mode 100644
index 00000000000000..b53191dbcb97e5
--- /dev/null
+++ b/src/tests/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125.tt
@@ -0,0 +1,113 @@
+<#@ template debug="false" hostspecific="true" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ output extension=".cs" #>
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Runtime_64125.cs is AUTOGENERATED. DO NOT MODIFY the file manually.
+// Instead use the following command to generate the .cs file from .tt file.
+//   "%DevEnvDir%\TextTransform.exe" Runtime_64125.tt
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Runtime_64125
+{
+<#
+    int[] byteCounts = new int[] { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
+    int[] offsets = new int[] { 252, 255, 504, 1008, 4095, 8190, 16380, 32760, 65520 };
+
+    int maximumByteCount = byteCounts.Max();
+    int maximumOffset = offsets.Max();
+
+    foreach (int byteCount in byteCounts)
+    {
+#>
+    [StructLayout(LayoutKind.Explicit, Size=<#= byteCount #>)]
+    struct Struct<#= byteCount #>Bytes
+    {
+    }
+
+<#
+    }
+#>
+    [StructLayout(LayoutKind.Explicit, Size=<#= maximumByteCount + maximumOffset #>)]
+    struct AnyOffset
+    {
+<#
+    foreach (int fieldOffset in offsets)
+    {
+#>
+        [FieldOffset(<#= fieldOffset #>)]
+        public byte fieldAtOffset<#= fieldOffset #>;
+<#
+    }
+#>
+    }
+
+    class AnyLocation
+    {
+<#
+    foreach (int byteCount in byteCounts)
+    foreach (int srcOffset in offsets)
+    foreach (int dstOffset in offsets)
+    {
+        string structByteCount = $"Struct{byteCount}Bytes";
+#>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public unsafe void Copy<#= byteCount #>BytesFromLocationAtOffset<#= srcOffset #>ToLocationAtOffset<#= dstOffset #>(AnyOffset* dst, AnyOffset* src)
+        {
+            *(<#= structByteCount #>*)&dst->fieldAtOffset<#= dstOffset #> = *(<#= structByteCount #>*)&src->fieldAtOffset<#= srcOffset #>;
+        }
+
+<#
+    }
+#>
+    }
+
+    class Program
+    {
+        static unsafe void Init(byte* bytes, int byteCount)
+        {
+            for (int i = 0; i < byteCount; i++)
+            {
+                bytes[i] = TestLibrary.Generator.GetByte();
+            }
+        }
+
+        static unsafe bool MemoryCompare(byte* left, byte* right, int byteCount)
+        {
+            for (int i = 0; i < byteCount; i++)
+            {
+                if (left[i] != right[i]) return false;
+            }
+
+            return true;
+        }
+
+        static unsafe int Main(string[] args)
+        {
+            var anyLocation = new AnyLocation();
+
+            var src = new AnyOffset();
+            var dst = new AnyOffset();
+
+            Init((byte*)&src, sizeof(AnyOffset));
+<#
+    foreach (int byteCount in byteCounts)
+    foreach (int srcOffset in offsets)
+    foreach (int dstOffset in offsets)
+    {
+#>
+            anyLocation.Copy<#= byteCount #>BytesFromLocationAtOffset<#= srcOffset #>ToLocationAtOffset<#= dstOffset #>(&dst, &src);
+            if (!MemoryCompare(&src.fieldAtOffset<#= srcOffset #>, &dst.fieldAtOffset<#= dstOffset #>, <#= byteCount #>)) return 0;
+<#
+    }
+#>
+
+            return 100;
+        }
+    }
+}
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index 7de0a388786697..2b1420abd4f7c1 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -2502,6 +2502,9 @@
         <ExcludeList Include = "$(XunitTestBinBase)JIT/IL_Conformance/Old/Base/ckfinite/**">
             <Issue>https://github.com/dotnet/runtime/issues/54376</Issue>
         </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125/**">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
         <!-- End interpreter issues -->
     </ItemGroup>
 
@@ -3346,6 +3349,9 @@
         <ExcludeList Include = "$(XunitTestBinBase)/JIT/Performance/CodeQuality/SIMD/RayTracer/RayTracer/**">
             <Issue>needs triage</Issue>
         </ExcludeList>
+        <ExcludeList Include = "$(XunitTestBinBase)/JIT/Regression/JitBlue/Runtime_64125/Runtime_64125/**">
+            <Issue>needs triage</Issue>
+        </ExcludeList>
     </ItemGroup>
 
     <ItemGroup Condition=" $(TargetOS) == 'Android' " >

From 9eb90511ff6d079fa02832936c693d36289fc02b Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 27 Jan 2022 19:25:02 -0500
Subject: [PATCH 127/161] Fix ExitDetectionNotBlockedByHandler test (#64407)

---
 src/libraries/System.Console/tests/CancelKeyPress.Unix.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs b/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs
index 8fd95102c9dbab..2a8bc01fcf2b45 100644
--- a/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs
+++ b/src/libraries/System.Console/tests/CancelKeyPress.Unix.cs
@@ -76,8 +76,9 @@ public void ExitDetectionNotBlockedByHandler()
                 Assert.Equal(RemoteExecutor.SuccessExitCode, handle.ExitCode);
             }
 
-            // Release CancelKeyPress
+            // Release CancelKeyPress, and give it time to return and tear down the app
             mre.Set();
+            Thread.Sleep(WaitFailTestTimeoutSeconds * 1000);
         }, new RemoteInvokeOptions() { ExpectedExitCode = 130 }).Dispose();
     }
 

From 479ee518f32cfaf53285b915265ccead9b6b13c9 Mon Sep 17 00:00:00 2001
From: Andy Ayers <andya@microsoft.com>
Date: Thu, 27 Jan 2022 17:24:38 -0800
Subject: [PATCH 128/161] enable osr stress tests for libraries and add fixes
 (#64116)

* add osr plus stress tests for libraries
* (Fix) have tier0 method always report generics context, then OSR method can just use that
* Add ability to suppress patchpoints by hash.
* Dump IR after patchpoints phase, if any were added
* (Fix) Fix bug in recursive tail call detection -- if we devirtualize we need to update the method handle we use.  OSR methods rely on getting this detection right so they know if they need to import the method entry block.
* (Fix) refine OSR enabling/backoff to opt logic. With OSR enabled, we were forcing too many methods to be optimized.
* reorder phase whitelist to more closely match phase order
---
 eng/pipelines/libraries/run-test-job.yml |  4 +++
 src/coreclr/jit/codegencommon.cpp        | 25 +++++++++++---
 src/coreclr/jit/compiler.cpp             | 42 ++++++++++++++----------
 src/coreclr/jit/compiler.hpp             | 18 ++++++++--
 src/coreclr/jit/importer.cpp             | 28 ++++++++++++----
 src/coreclr/jit/jitconfigvalues.h        | 12 +++++--
 src/coreclr/jit/phase.cpp                |  5 +--
 7 files changed, 99 insertions(+), 35 deletions(-)

diff --git a/eng/pipelines/libraries/run-test-job.yml b/eng/pipelines/libraries/run-test-job.yml
index d864487760908b..0f2070a49bfbf7 100644
--- a/eng/pipelines/libraries/run-test-job.yml
+++ b/eng/pipelines/libraries/run-test-job.yml
@@ -191,4 +191,8 @@ jobs:
               - fullpgo_random_gdv
               - fullpgo_random_edge
               - fullpgo_random_gdv_edge
+              - jitosr
+              - jitosr_stress
+              - jitosr_stress_random
+              - jitosr_pgo
 
diff --git a/src/coreclr/jit/codegencommon.cpp b/src/coreclr/jit/codegencommon.cpp
index 1c9eda6f63afc1..fe8b2d82dcaec9 100644
--- a/src/coreclr/jit/codegencommon.cpp
+++ b/src/coreclr/jit/codegencommon.cpp
@@ -6385,16 +6385,31 @@ void CodeGen::genEnregisterOSRArgsAndLocals()
 
 void CodeGen::genReportGenericContextArg(regNumber initReg, bool* pInitRegZeroed)
 {
-    // For OSR the original method has set this up for us.
+    assert(compiler->compGeneratingProlog);
+
+    const bool reportArg = compiler->lvaReportParamTypeArg();
+
     if (compiler->opts.IsOSR())
     {
+        PatchpointInfo* const ppInfo = compiler->info.compPatchpointInfo;
+        if (reportArg)
+        {
+            // OSR method will use Tier0 slot to report context arg.
+            //
+            assert(ppInfo->HasGenericContextArgOffset());
+            JITDUMP("OSR method will use Tier0 frame slot for generics context arg.\n");
+        }
+        else if (compiler->lvaKeepAliveAndReportThis())
+        {
+            // OSR method will use Tier0 slot to report `this` as context.
+            //
+            assert(ppInfo->HasKeptAliveThis());
+            JITDUMP("OSR method will use Tier0 frame slot for generics context `this`.\n");
+        }
+
         return;
     }
 
-    assert(compiler->compGeneratingProlog);
-
-    bool reportArg = compiler->lvaReportParamTypeArg();
-
     // We should report either generic context arg or "this" when used so.
     if (!reportArg)
     {
diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp
index e85192d1905938..f6299e5bf35619 100644
--- a/src/coreclr/jit/compiler.cpp
+++ b/src/coreclr/jit/compiler.cpp
@@ -6396,9 +6396,10 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr,
         // Honor the config setting that tells the jit to
         // always optimize methods with loops.
         //
-        // If that's not set, and OSR is enabled, the jit may still
+        // If neither of those apply, and OSR is enabled, the jit may still
         // decide to optimize, if there's something in the method that
-        // OSR currently cannot handle.
+        // OSR currently cannot handle, or we're optionally suppressing
+        // OSR by method hash.
         //
         const char* reason = nullptr;
 
@@ -6406,35 +6407,42 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr,
         {
             reason = "tail.call and not BBINSTR";
         }
-        else if ((info.compFlags & CORINFO_FLG_DISABLE_TIER0_FOR_LOOPS) != 0)
+        else if (compHasBackwardJump && ((info.compFlags & CORINFO_FLG_DISABLE_TIER0_FOR_LOOPS) != 0))
         {
-            if (compHasBackwardJump)
-            {
-                reason = "loop";
-            }
+            reason = "loop";
         }
-        else if (JitConfig.TC_OnStackReplacement() > 0)
+
+        if (compHasBackwardJump && (reason == nullptr) && (JitConfig.TC_OnStackReplacement() > 0))
         {
-            const bool patchpointsOK = compCanHavePatchpoints(&reason);
-            assert(patchpointsOK || (reason != nullptr));
+            const char* noPatchpointReason = nullptr;
+            bool        canEscapeViaOSR    = compCanHavePatchpoints(&reason);
 
 #ifdef DEBUG
-            // Optionally disable OSR by method hash.
-            //
-            if (patchpointsOK && compHasBackwardJump)
+            if (canEscapeViaOSR)
             {
+                // Optionally disable OSR by method hash. This will force any
+                // method that might otherwise get trapped in Tier0 to be optimized.
+                //
                 static ConfigMethodRange JitEnableOsrRange;
                 JitEnableOsrRange.EnsureInit(JitConfig.JitEnableOsrRange());
                 const unsigned hash = impInlineRoot()->info.compMethodHash();
                 if (!JitEnableOsrRange.Contains(hash))
                 {
-                    JITDUMP("Disabling OSR -- Method hash 0x%08x not within range ", hash);
-                    JITDUMPEXEC(JitEnableOsrRange.Dump());
-                    JITDUMP("\n");
-                    reason = "OSR disabled by JitEnableOsrRange";
+                    canEscapeViaOSR = false;
+                    reason          = "OSR disabled by JitEnableOsrRange";
                 }
             }
 #endif
+
+            if (canEscapeViaOSR)
+            {
+                JITDUMP("\nOSR enabled for this method\n");
+            }
+            else
+            {
+                JITDUMP("\nOSR disabled for this method: %s\n", noPatchpointReason);
+                assert(reason != nullptr);
+            }
         }
 
         if (reason != nullptr)
diff --git a/src/coreclr/jit/compiler.hpp b/src/coreclr/jit/compiler.hpp
index 5a7b17f776f2c6..464cafeb72750e 100644
--- a/src/coreclr/jit/compiler.hpp
+++ b/src/coreclr/jit/compiler.hpp
@@ -1986,13 +1986,18 @@ inline bool Compiler::lvaKeepAliveAndReportThis()
     // the VM requires us to keep the generics context alive or it is used in a look-up.
     // We keep it alive in the lookup scenario, even when the VM didn't ask us to,
     // because collectible types need the generics context when gc-ing.
+    //
+    // Methoods that can inspire OSR methods must always report context as live
+    //
     if (genericsContextIsThis)
     {
-        const bool mustKeep = (info.compMethodInfo->options & CORINFO_GENERICS_CTXT_KEEP_ALIVE) != 0;
+        const bool mustKeep      = (info.compMethodInfo->options & CORINFO_GENERICS_CTXT_KEEP_ALIVE) != 0;
+        const bool hasPatchpoint = doesMethodHavePatchpoints() || doesMethodHavePartialCompilationPatchpoints();
 
-        if (lvaGenericsContextInUse || mustKeep)
+        if (lvaGenericsContextInUse || mustKeep || hasPatchpoint)
         {
-            JITDUMP("Reporting this as generic context: %s\n", mustKeep ? "must keep" : "referenced");
+            JITDUMP("Reporting this as generic context: %s\n",
+                    mustKeep ? "must keep" : (hasPatchpoint ? "patchpoints" : "referenced"));
             return true;
         }
     }
@@ -2024,6 +2029,13 @@ inline bool Compiler::lvaReportParamTypeArg()
         {
             return true;
         }
+
+        // Methoods that have patchpoints always report context as live
+        //
+        if (doesMethodHavePatchpoints() || doesMethodHavePartialCompilationPatchpoints())
+        {
+            return true;
+        }
     }
 
     // Otherwise, we don't need to report it -- the generics context parameter is unused.
diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp
index 9668b22c5ebf87..ca697139a8904c 100644
--- a/src/coreclr/jit/importer.cpp
+++ b/src/coreclr/jit/importer.cpp
@@ -9540,6 +9540,10 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
                                 // Take care to pass raw IL offset here as the 'debug info' might be different for
                                 // inlinees.
                                 rawILOffset);
+
+            // Devirtualization may change which method gets invoked. Update our local cache.
+            //
+            methHnd = callInfo->hMethod;
         }
 
         if (impIsThis(obj))
@@ -11803,9 +11807,21 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
 #ifdef FEATURE_ON_STACK_REPLACEMENT
 
-    // Is OSR enabled?
+    bool enablePatchpoints = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_TIER0) && (JitConfig.TC_OnStackReplacement() > 0);
+
+#ifdef DEBUG
+
+    // Optionally suppress patchpoints by method hash
     //
-    if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_TIER0) && (JitConfig.TC_OnStackReplacement() > 0))
+    static ConfigMethodRange JitEnablePatchpointRange;
+    JitEnablePatchpointRange.EnsureInit(JitConfig.JitEnablePatchpointRange());
+    const unsigned hash    = impInlineRoot()->info.compMethodHash();
+    const bool     inRange = JitEnablePatchpointRange.Contains(hash);
+    enablePatchpoints &= inRange;
+
+#endif // DEBUG
+
+    if (enablePatchpoints)
     {
         // We don't inline at Tier0, if we do, we may need rethink our approach.
         // Could probably support inlines that don't introduce flow.
@@ -11820,13 +11836,13 @@ void Compiler::impImportBlockCode(BasicBlock* block)
         //
         if (!compTailPrefixSeen)
         {
-            assert(compCanHavePatchpoints());
-
             // The normaly policy is only to add patchpoints to the targets of lexically
             // backwards branches.
             //
             if (compHasBackwardJump)
             {
+                assert(compCanHavePatchpoints());
+
                 // Is the start of this block a suitable patchpoint?
                 //
                 if (((block->bbFlags & BBF_BACKWARD_JUMP_TARGET) != 0) && (verCurrentState.esStackDepth == 0))
@@ -11857,8 +11873,8 @@ void Compiler::impImportBlockCode(BasicBlock* block)
         const bool tryOffsetOSR = offsetOSR >= 0;
         const bool tryRandomOSR = randomOSR > 0;
 
-        if ((tryOffsetOSR || tryRandomOSR) && (verCurrentState.esStackDepth == 0) && !block->hasHndIndex() &&
-            ((block->bbFlags & BBF_PATCHPOINT) == 0))
+        if (compCanHavePatchpoints() && (tryOffsetOSR || tryRandomOSR) && (verCurrentState.esStackDepth == 0) &&
+            !block->hasHndIndex() && ((block->bbFlags & BBF_PATCHPOINT) == 0))
         {
             // Block start can have a patchpoint. See if we should add one.
             //
diff --git a/src/coreclr/jit/jitconfigvalues.h b/src/coreclr/jit/jitconfigvalues.h
index 4fc4594c6fb2b9..1346c2069da170 100644
--- a/src/coreclr/jit/jitconfigvalues.h
+++ b/src/coreclr/jit/jitconfigvalues.h
@@ -471,8 +471,16 @@ CONFIG_INTEGER(JitOffsetOnStackReplacement, W("JitOffsetOnStackReplacement"), -1
 #endif // debug
 
 #if defined(DEBUG)
-CONFIG_STRING(JitEnableOsrRange, W("JitEnableOsrRange")) // Enable osr for only some methods
-#endif                                                   // debug
+// EnableOsrRange allows you to limit the set of methods that will rely on OSR to escape
+// from Tier0 code. Methods outside the range that would normally be jitted at Tier0
+// and have patchpoints will instead be switched to optimized.
+CONFIG_STRING(JitEnableOsrRange, W("JitEnableOsrRange"))
+// EnablePatchpointRange allows you to limit the set of Tier0 methods that
+// will have patchpoints, and hence control which methods will create OSR methods.
+// Unlike EnableOsrRange, it will not alter the optimization setting for methods
+// outside the enabled range.
+CONFIG_STRING(JitEnablePatchpointRange, W("JitEnablePatchpointRange"))
+#endif
 
 // Profile instrumentation options
 CONFIG_INTEGER(JitMinimalJitProfiling, W("JitMinimalJitProfiling"), 1)
diff --git a/src/coreclr/jit/phase.cpp b/src/coreclr/jit/phase.cpp
index 7bcc372cb0cf82..5f2e2172c6f4a5 100644
--- a/src/coreclr/jit/phase.cpp
+++ b/src/coreclr/jit/phase.cpp
@@ -167,10 +167,11 @@ void Phase::PostPhase(PhaseStatus status)
     // clang-format off
 
     static Phases s_allowlist[] = {
+        PHASE_INCPROFILE,
+        PHASE_IBCPREP,
         PHASE_IMPORTATION,
+        PHASE_PATCHPOINTS,
         PHASE_IBCINSTR,
-        PHASE_IBCPREP,
-        PHASE_INCPROFILE,
         PHASE_INDXCALL,
         PHASE_MORPH_INLINE,
         PHASE_ALLOCATE_OBJECTS,

From f8f486b44bf7a1cb1e07073fed425522245b7731 Mon Sep 17 00:00:00 2001
From: Tarek Mahmoud Sayed <tarekms@microsoft.com>
Date: Thu, 27 Jan 2022 18:16:56 -0800
Subject: [PATCH 129/161] Fix DateOnly and TimeOnly Formatting using
 interpolated strings (#64398)

---
 .../System.Private.CoreLib/src/System/DateOnly.cs     |  6 ++----
 .../src/System/Globalization/DateTimeFormat.cs        |  8 ++++----
 .../src/System/ISpanFormattable.cs                    |  1 +
 .../System.Private.CoreLib/src/System/TimeOnly.cs     |  6 ++----
 .../System.Runtime/tests/System/DateOnlyTests.cs      | 10 ++++++++++
 .../System.Runtime/tests/System/TimeOnlyTests.cs      | 11 +++++++++++
 6 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/src/libraries/System.Private.CoreLib/src/System/DateOnly.cs b/src/libraries/System.Private.CoreLib/src/System/DateOnly.cs
index e6fbd541653294..25bd0d15bb8b3f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/DateOnly.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/DateOnly.cs
@@ -817,15 +817,13 @@ public string ToString(string? format, IFormatProvider? provider)
                         return DateTimeFormat.TryFormat(GetEquivalentDateTime(), destination, out charsWritten, format, provider);
 
                     default:
-                        charsWritten = 0;
-                        return false;
+                        throw new FormatException(SR.Argument_BadFormatSpecifier);
                 }
             }
 
             if (!DateTimeFormat.IsValidCustomDateFormat(format, throwOnError: false))
             {
-                charsWritten = 0;
-                return false;
+                throw new FormatException(SR.Format(SR.Format_DateTimeOnlyContainsNoneDateParts, format.ToString(), nameof(DateOnly)));
             }
 
             return DateTimeFormat.TryFormat(GetEquivalentDateTime(), destination, out charsWritten, format, provider);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs
index e72e7885566401..f8c1745c1e4994 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs
@@ -62,8 +62,8 @@ Patterns   Format      Description                           Example
         "M"     "0"         month w/o leading zero                2
         "MM"    "00"        month with leading zero               02
         "MMM"               short month name (abbreviation)       Feb
-        "MMMM"              full month name                       Febuary
-        "MMMM*"             full month name                       Febuary
+        "MMMM"              full month name                       February
+        "MMMM*"             full month name                       February
 
         "y"     "0"         two digit year (year % 100) w/o leading zero           0
         "yy"    "00"        two digit year (year % 100) with leading zero          00
@@ -734,7 +734,7 @@ private static StringBuilder FormatCustomized(
                         break;
                     case '\\':
                         // Escaped character.  Can be used to insert a character into the format string.
-                        // For exmple, "\d" will insert the character 'd' into the string.
+                        // For example, "\d" will insert the character 'd' into the string.
                         //
                         // NOTENOTE : we can remove this format character if we enforce the enforced quote
                         // character rule.
@@ -966,7 +966,7 @@ private static string ExpandPredefinedFormat(ReadOnlySpan<char> format, ref Date
                         // This format is not supported by DateTimeOffset
                         throw new FormatException(SR.Format_InvalidString);
                     }
-                    // Universal time is always in Greogrian calendar.
+                    // Universal time is always in Gregorian calendar.
                     //
                     // Change the Calendar to be Gregorian Calendar.
                     //
diff --git a/src/libraries/System.Private.CoreLib/src/System/ISpanFormattable.cs b/src/libraries/System.Private.CoreLib/src/System/ISpanFormattable.cs
index 0998785f780ba3..15e7717435d960 100644
--- a/src/libraries/System.Private.CoreLib/src/System/ISpanFormattable.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/ISpanFormattable.cs
@@ -15,6 +15,7 @@ public interface ISpanFormattable : IFormattable
         /// <remarks>
         /// An implementation of this interface should produce the same string of characters as an implementation of <see cref="IFormattable.ToString(string?, IFormatProvider?)"/>
         /// on the same type.
+        /// TryFormat should return false only if there is not enough space in the destination buffer. Any other failures should throw an exception.
         /// </remarks>
         bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider);
     }
diff --git a/src/libraries/System.Private.CoreLib/src/System/TimeOnly.cs b/src/libraries/System.Private.CoreLib/src/System/TimeOnly.cs
index ee3d11925d0c36..a979ce561452e6 100644
--- a/src/libraries/System.Private.CoreLib/src/System/TimeOnly.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/TimeOnly.cs
@@ -892,15 +892,13 @@ public string ToString(string? format, IFormatProvider? provider)
                         return DateTimeFormat.TryFormat(ToDateTime(), destination, out charsWritten, format, provider);
 
                     default:
-                        charsWritten = 0;
-                        return false;
+                        throw new FormatException(SR.Argument_BadFormatSpecifier);
                 }
             }
 
             if (!DateTimeFormat.IsValidCustomTimeFormat(format, throwOnError: false))
             {
-                charsWritten = 0;
-                return false;
+                throw new FormatException(SR.Format(SR.Format_DateTimeOnlyContainsNoneDateParts, format.ToString(), nameof(TimeOnly)));
             }
 
             return DateTimeFormat.TryFormat(ToDateTime(), destination, out charsWritten, format, provider);
diff --git a/src/libraries/System.Runtime/tests/System/DateOnlyTests.cs b/src/libraries/System.Runtime/tests/System/DateOnlyTests.cs
index 935c75e01bb7c3..624b9b508a868e 100644
--- a/src/libraries/System.Runtime/tests/System/DateOnlyTests.cs
+++ b/src/libraries/System.Runtime/tests/System/DateOnlyTests.cs
@@ -513,6 +513,16 @@ public static void TryFormatTest()
             Assert.False(dateOnly.TryFormat(buffer.Slice(0, 3), out charsWritten));
             Assert.False(dateOnly.TryFormat(buffer.Slice(0, 3), out charsWritten, "r"));
             Assert.False(dateOnly.TryFormat(buffer.Slice(0, 3), out charsWritten, "O"));
+            Assert.Throws<FormatException>(() => {
+                    Span<char> buff = stackalloc char[100];
+                    dateOnly.TryFormat(buff, out charsWritten, "u");
+                });
+            Assert.Throws<FormatException>(() => {
+                    Span<char> buff = stackalloc char[100];
+                    dateOnly.TryFormat(buff, out charsWritten, "hh-ss");
+                });
+            Assert.Throws<FormatException>(() => $"{dateOnly:u}");
+            Assert.Throws<FormatException>(() => $"{dateOnly:hh-ss}");
         }
     }
 }
diff --git a/src/libraries/System.Runtime/tests/System/TimeOnlyTests.cs b/src/libraries/System.Runtime/tests/System/TimeOnlyTests.cs
index b39e94e00d1dc9..f74a4012747489 100644
--- a/src/libraries/System.Runtime/tests/System/TimeOnlyTests.cs
+++ b/src/libraries/System.Runtime/tests/System/TimeOnlyTests.cs
@@ -483,6 +483,17 @@ public static void TryFormatTest()
             Assert.False(timeOnly.TryFormat(buffer.Slice(0, 3), out charsWritten));
             Assert.False(timeOnly.TryFormat(buffer.Slice(0, 3), out charsWritten, "r"));
             Assert.False(timeOnly.TryFormat(buffer.Slice(0, 3), out charsWritten, "O"));
+
+            Assert.Throws<FormatException>(() => {
+                    Span<char> buff = stackalloc char[100];
+                    timeOnly.TryFormat(buff, out charsWritten, "u");
+                });
+            Assert.Throws<FormatException>(() => {
+                    Span<char> buff = stackalloc char[100];
+                    timeOnly.TryFormat(buff, out charsWritten, "dd-yyyy");
+                });
+            Assert.Throws<FormatException>(() => $"{timeOnly:u}");
+            Assert.Throws<FormatException>(() => $"{timeOnly:dd-yyyy}");
         }
     }
 }

From 312f23d67859ab47e041d40c621929a0ee31509e Mon Sep 17 00:00:00 2001
From: Robert Henry <robhenry@microsoft.com>
Date: Thu, 27 Jan 2022 18:18:23 -0800
Subject: [PATCH 130/161] gcc compilations for ARM64 can not initialize extern
 "C" variables. (#64239)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Clang compilations for ARM64 can not initialize extern "C" variables.

Some versions of clang targeted to ARM64 do not allow extern "C"
variables to be initialized at the point of extern "C" declarations,
although this many not be caught until the assembler of linker is run,
at which time an illegal relocation type is discovered.

Per advice from Jan Vorlicek.

* Change 6 initialized extern "C" declarations to split declaration and initialization.

This seems to remove 2*6==12 warning errors
  initialized and declared ‘extern’
some of which were errors with modern gcc on ARM64.

* Correctly declare extern "C" ...  JIT_WriteBarrier_Loc and companion.
---
 src/coreclr/nativeaot/Runtime/DebugHeader.cpp | 3 ++-
 src/coreclr/nativeaot/Runtime/gcrhenv.cpp     | 3 ++-
 src/coreclr/nativeaot/Runtime/startup.cpp     | 7 +++++--
 src/coreclr/nativeaot/Runtime/threadstore.cpp | 6 ++++--
 src/coreclr/vm/threads.cpp                    | 8 ++++++--
 5 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/coreclr/nativeaot/Runtime/DebugHeader.cpp b/src/coreclr/nativeaot/Runtime/DebugHeader.cpp
index e1025ce27e664c..76b603906cf7ca 100644
--- a/src/coreclr/nativeaot/Runtime/DebugHeader.cpp
+++ b/src/coreclr/nativeaot/Runtime/DebugHeader.cpp
@@ -109,7 +109,8 @@ struct DotNetRuntimeDebugHeader
 #ifdef TARGET_WINDOWS
 #pragma comment (linker, "/EXPORT:DotNetRuntimeDebugHeader,DATA")
 #endif
-extern "C" DotNetRuntimeDebugHeader DotNetRuntimeDebugHeader = {};
+extern "C" struct DotNetRuntimeDebugHeader DotNetRuntimeDebugHeader;
+struct DotNetRuntimeDebugHeader DotNetRuntimeDebugHeader = {};
 
 #define MAKE_DEBUG_ENTRY(TypeName, FieldName, Value)                             \
     do                                                                           \
diff --git a/src/coreclr/nativeaot/Runtime/gcrhenv.cpp b/src/coreclr/nativeaot/Runtime/gcrhenv.cpp
index 2f6f6ea4f7c0c0..0001de5370c1db 100644
--- a/src/coreclr/nativeaot/Runtime/gcrhenv.cpp
+++ b/src/coreclr/nativeaot/Runtime/gcrhenv.cpp
@@ -585,7 +585,8 @@ void RedhawkGCInterface::UnregisterFrozenSegment(GcSegmentHandle segment)
     GCHeapUtilities::GetGCHeap()->UnregisterFrozenSegment((segment_handle)segment);
 }
 
-EXTERN_C UInt32_BOOL g_fGcStressStarted = UInt32_FALSE; // UInt32_BOOL because asm code reads it
+EXTERN_C UInt32_BOOL g_fGcStressStarted;
+UInt32_BOOL g_fGcStressStarted = UInt32_FALSE; // UInt32_BOOL because asm code reads it
 #ifdef FEATURE_GC_STRESS
 // static
 void RedhawkGCInterface::StressGc()
diff --git a/src/coreclr/nativeaot/Runtime/startup.cpp b/src/coreclr/nativeaot/Runtime/startup.cpp
index ada010f8a573e6..9f82aebdbf39eb 100644
--- a/src/coreclr/nativeaot/Runtime/startup.cpp
+++ b/src/coreclr/nativeaot/Runtime/startup.cpp
@@ -45,14 +45,17 @@ static bool DetectCPUFeatures();
 
 extern RhConfig * g_pRhConfig;
 
-EXTERN_C bool g_fHasFastFxsave = false;
+EXTERN_C bool g_fHasFastFxsave;
+bool g_fHasFastFxsave = false;
 
 CrstStatic g_CastCacheLock;
 CrstStatic g_ThunkPoolLock;
 
 #if defined(HOST_X86) || defined(HOST_AMD64) || defined(HOST_ARM64)
 // This field is inspected from the generated code to determine what intrinsics are available.
-EXTERN_C int g_cpuFeatures = 0;
+EXTERN_C int g_cpuFeatures;
+int g_cpuFeatures = 0;
+
 // This field is defined in the generated code and sets the ISA expectations.
 EXTERN_C int g_requiredCpuFeatures;
 #endif
diff --git a/src/coreclr/nativeaot/Runtime/threadstore.cpp b/src/coreclr/nativeaot/Runtime/threadstore.cpp
index e0a7d528358ab5..36bf43c1a359f0 100644
--- a/src/coreclr/nativeaot/Runtime/threadstore.cpp
+++ b/src/coreclr/nativeaot/Runtime/threadstore.cpp
@@ -27,7 +27,8 @@
 #include "slist.inl"
 #include "GCMemoryHelpers.h"
 
-EXTERN_C volatile uint32_t RhpTrapThreads = (uint32_t)TrapThreadsFlags::None;
+EXTERN_C volatile uint32_t RhpTrapThreads;
+volatile uint32_t RhpTrapThreads = (uint32_t)TrapThreadsFlags::None;
 
 GVAL_IMPL_INIT(PTR_Thread, RhpSuspendingThread, 0);
 
@@ -373,7 +374,8 @@ COOP_PINVOKE_HELPER(void, RhpCancelThreadAbort, (void* thread))
 
 C_ASSERT(sizeof(Thread) == sizeof(ThreadBuffer));
 
-EXTERN_C DECLSPEC_THREAD ThreadBuffer tls_CurrentThread =
+EXTERN_C DECLSPEC_THREAD ThreadBuffer tls_CurrentThread;
+DECLSPEC_THREAD ThreadBuffer tls_CurrentThread =
 {
     { 0 },                              // m_rgbAllocContextBuffer
     Thread::TSF_Unknown,                // m_ThreadStateFlags
diff --git a/src/coreclr/vm/threads.cpp b/src/coreclr/vm/threads.cpp
index 200d36586ef52a..de38922580b79c 100644
--- a/src/coreclr/vm/threads.cpp
+++ b/src/coreclr/vm/threads.cpp
@@ -1124,8 +1124,12 @@ extern "C" void *JIT_WriteBarrier_Loc;
 
 #ifdef TARGET_ARM64
 extern "C" void (*JIT_WriteBarrier_Table)();
-extern "C" void *JIT_WriteBarrier_Loc = 0;
-extern "C" void *JIT_WriteBarrier_Table_Loc = 0;
+
+extern "C" void *JIT_WriteBarrier_Loc;
+void *JIT_WriteBarrier_Loc = 0;
+
+extern "C" void *JIT_WriteBarrier_Table_Loc;
+void *JIT_WriteBarrier_Table_Loc = 0;
 #endif // TARGET_ARM64
 
 #ifdef TARGET_ARM

From c264b260d46e28ec0b58da194bae501d21548dcc Mon Sep 17 00:00:00 2001
From: Tarek Mahmoud Sayed <tarekms@microsoft.com>
Date: Thu, 27 Jan 2022 18:41:30 -0800
Subject: [PATCH 131/161] Add Metrics UpDownCounter (#64365)

Co-authored-by: Noah Falk <noahfalk@users.noreply.github.com>
---
 ...em.Diagnostics.DiagnosticSourceActivity.cs |  47 +-
 ...System.Diagnostics.DiagnosticSource.csproj |   2 +
 .../src/System/Diagnostics/Metrics/Meter.cs   |  54 +++
 .../Metrics/ObservableUpDownCounter.cs        |  61 +++
 .../Diagnostics/Metrics/UpDownCounter.cs      |  76 +++
 .../tests/MetricsTests.cs                     | 435 ++++++++++++++----
 6 files changed, 584 insertions(+), 91 deletions(-)
 create mode 100644 src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/ObservableUpDownCounter.cs
 create mode 100644 src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/UpDownCounter.cs

diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs b/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs
index a94fb9e380da8e..3ab7c480affb74 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs
@@ -307,15 +307,27 @@ namespace System.Diagnostics.Metrics
 {
     public sealed class Counter<T> : Instrument<T> where T : struct
     {
-        public void Add(T delta) {  throw null; }
-        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag)  {  throw null; }
-        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2)  {  throw null; }
-        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2, System.Collections.Generic.KeyValuePair<string, object?> tag3)  {  throw null; }
-        public void Add(T delta, ReadOnlySpan<System.Collections.Generic.KeyValuePair<string, object?>> tags) {  throw null; }
-        public void Add(T delta, params System.Collections.Generic.KeyValuePair<string, object?>[] tags) {  throw null; }
+        public void Add(T delta) { throw null; }
+        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag)  { throw null; }
+        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2)  { throw null; }
+        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2, System.Collections.Generic.KeyValuePair<string, object?> tag3)  { throw null; }
+        public void Add(T delta, ReadOnlySpan<System.Collections.Generic.KeyValuePair<string, object?>> tags) { throw null; }
+        public void Add(T delta, params System.Collections.Generic.KeyValuePair<string, object?>[] tags) { throw null; }
         public void Add(T delta, in TagList tagList) { throw null; }
         internal Counter(Meter meter, string name, string? unit, string? description) :
-                        base(meter, name, unit, description) {  throw null; }
+                        base(meter, name, unit, description) { throw null; }
+    }
+    public sealed class UpDownCounter<T> : Instrument<T> where T : struct
+    {
+        public void Add(T delta) { throw null; }
+        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag)  { throw null; }
+        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2)  { throw null; }
+        public void Add(T delta, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2, System.Collections.Generic.KeyValuePair<string, object?> tag3)  { throw null; }
+        public void Add(T delta, ReadOnlySpan<System.Collections.Generic.KeyValuePair<string, object?>> tags) { throw null; }
+        public void Add(T delta, params System.Collections.Generic.KeyValuePair<string, object?>[] tags) { throw null; }
+        public void Add(T delta, in TagList tagList) { throw null; }
+        internal UpDownCounter(Meter meter, string name, string? unit, string? description) :
+                        base(meter, name, unit, description) { throw null; }
     }
     public sealed class Histogram<T> : Instrument<T> where T : struct
     {
@@ -362,6 +374,7 @@ public abstract class Instrument<T> : Instrument where T : struct
     public class Meter : IDisposable
     {
         public Counter<T> CreateCounter<T>(string name, string? unit = null, string? description = null) where T : struct  { throw null; }
+        public UpDownCounter<T> CreateUpDownCounter<T>(string name, string? unit = null, string? description = null) where T : struct  { throw null; }
         public Histogram<T> CreateHistogram<T>(string name, string? unit = null, string? description = null) where T : struct { throw null; }
         public ObservableCounter<T> CreateObservableCounter<T>(
                             string name,
@@ -378,6 +391,21 @@ public ObservableCounter<T> CreateObservableCounter<T>(
                             Func<System.Collections.Generic.IEnumerable<Measurement<T>>> observeValues,
                             string? unit = null,
                             string? description = null) where T : struct { throw null; }
+        public ObservableUpDownCounter<T> CreateObservableUpDownCounter<T>(
+                            string name,
+                            Func<T> observeValue,
+                            string? unit = null,
+                            string? description = null) where T : struct { throw null; }
+        public ObservableUpDownCounter<T> CreateObservableUpDownCounter<T>(
+                            string name,
+                            Func<Measurement<T>> observeValue,
+                            string? unit = null,
+                            string? description = null) where T : struct { throw null; }
+        public ObservableUpDownCounter<T> CreateObservableUpDownCounter<T>(
+                            string name,
+                            Func<System.Collections.Generic.IEnumerable<Measurement<T>>> observeValues,
+                            string? unit = null,
+                            string? description = null) where T : struct { throw null; }
         public ObservableGauge<T> CreateObservableGauge<T>(
                             string name,
                             Func<T> observeValue,
@@ -416,6 +444,11 @@ public sealed class ObservableCounter<T> : ObservableInstrument<T> where T : str
         internal ObservableCounter(Meter meter, string name, string? unit, string? description) : base(meter, name, unit, description) { throw null; }
         protected override System.Collections.Generic.IEnumerable<Measurement<T>> Observe() { throw null;}
     }
+    public sealed class ObservableUpDownCounter<T> : ObservableInstrument<T> where T : struct
+    {
+        internal ObservableUpDownCounter(Meter meter, string name, string? unit, string? description) : base(meter, name, unit, description) { throw null; }
+        protected override System.Collections.Generic.IEnumerable<Measurement<T>> Observe() { throw null;}
+    }
     public sealed class ObservableGauge<T> : ObservableInstrument<T> where T : struct
     {
         internal ObservableGauge(Meter meter, string name, string? unit, string? description) : base(meter, name, unit, description) { throw null; }
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj b/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
index 510487abedfd3b..b2be804bdfbf19 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
@@ -72,11 +72,13 @@ System.Diagnostics.DiagnosticSource</PackageDescription>
     <Compile Include="System\Diagnostics\Metrics\ObservableCounter.cs" />
     <Compile Include="System\Diagnostics\Metrics\ObservableGauge.cs" />
     <Compile Include="System\Diagnostics\Metrics\ObservableInstrument.cs" />
+    <Compile Include="System\Diagnostics\Metrics\ObservableUpDownCounter.cs" />
     <Compile Include="System\Diagnostics\Metrics\RateAggregator.cs" />
     <Compile Include="System\Diagnostics\Metrics\StringSequence.cs" />
     <Compile Include="System\Diagnostics\Metrics\StringSequence.netcore.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'" />
     <Compile Include="System\Diagnostics\Metrics\StringSequence.netfx.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
     <Compile Include="System\Diagnostics\Metrics\TagList.cs" />
+    <Compile Include="System\Diagnostics\Metrics\UpDownCounter.cs" />
     <None Include="ActivityUserGuide.md" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs
index 7aa624c68bed28..b16bbf08835afa 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs
@@ -82,6 +82,59 @@ public Meter(string name, string? version)
         /// </remarks>
         public Histogram<T> CreateHistogram<T>(string name, string? unit = null, string? description = null) where T : struct => new Histogram<T>(this, name, unit, description);
 
+        /// <summary>
+        /// Create a metrics UpDownCounter object.
+        /// </summary>
+        /// <param name="name">The instrument name. Cannot be null.</param>
+        /// <param name="unit">Optional instrument unit of measurements.</param>
+        /// <param name="description">Optional instrument description.</param>
+        /// <remarks>
+        /// UpDownCounter is an Instrument which supports reporting positive or negative metric values.
+        /// Example uses for UpDownCounter: reporting the change in active requests or queue size.
+        /// </remarks>
+        public UpDownCounter<T> CreateUpDownCounter<T>(string name, string? unit = null, string? description = null) where T : struct => new UpDownCounter<T>(this, name, unit, description);
+
+        /// <summary>
+        /// Create an ObservableUpDownCounter object. ObservableUpDownCounter is an Instrument which reports increasing or decreasing value(s) when the instrument is being observed.
+        /// </summary>
+        /// <param name="name">The instrument name. Cannot be null.</param>
+        /// <param name="observeValue">The callback to call to get the measurements when the <see cref="ObservableCounter{t}.Observe" /> is called by <see cref="MeterListener.RecordObservableInstruments" />.</param>
+        /// <param name="unit">Optional instrument unit of measurements.</param>
+        /// <param name="description">Optional instrument description.</param>
+        /// <remarks>
+        /// Example uses for ObservableUpDownCounter: the process heap size or the approximate number of items in a lock-free circular buffer.
+        /// </remarks>
+        public ObservableUpDownCounter<T> CreateObservableUpDownCounter<T>(string name, Func<T> observeValue, string? unit = null, string? description = null) where T : struct =>
+                                        new ObservableUpDownCounter<T>(this, name, observeValue, unit, description);
+
+
+        /// <summary>
+        /// Create an ObservableUpDownCounter object. ObservableUpDownCounter is an Instrument which reports increasing or decreasing value(s) when the instrument is being observed.
+        /// </summary>
+        /// <param name="name">The instrument name. Cannot be null.</param>
+        /// <param name="observeValue">The callback to call to get the measurements when the <see cref="ObservableCounter{t}.Observe" /> is called by <see cref="MeterListener.RecordObservableInstruments" /></param>
+        /// <param name="unit">Optional instrument unit of measurements.</param>
+        /// <param name="description">Optional instrument description.</param>
+        /// <remarks>
+        /// Example uses for ObservableUpDownCounter: the process heap size or the approximate number of items in a lock-free circular buffer.
+        /// </remarks>
+        public ObservableUpDownCounter<T> CreateObservableUpDownCounter<T>(string name, Func<Measurement<T>> observeValue, string? unit = null, string? description = null) where T : struct =>
+                                        new ObservableUpDownCounter<T>(this, name, observeValue, unit, description);
+
+        /// <summary>
+        /// Create an ObservableUpDownCounter object. ObservableUpDownCounter is an Instrument which reports increasing or decreasing value(s) when the instrument is being observed.
+        /// </summary>
+        /// <param name="name">The instrument name. Cannot be null.</param>
+        /// <param name="observeValues">The callback to call to get the measurements when the <see cref="ObservableCounter{t}.Observe" /> is called by <see cref="MeterListener.RecordObservableInstruments" />.</param>
+        /// <param name="unit">Optional instrument unit of measurements.</param>
+        /// <param name="description">Optional instrument description.</param>
+        /// <remarks>
+        /// Example uses for ObservableUpDownCounter: the process heap size or the approximate number of items in a lock-free circular buffer.
+        /// </remarks>
+        public ObservableUpDownCounter<T> CreateObservableUpDownCounter<T>(string name, Func<IEnumerable<Measurement<T>>> observeValues, string? unit = null, string? description = null) where T : struct =>
+                                        new ObservableUpDownCounter<T>(this, name, observeValues, unit, description);
+
+
         /// <summary>
         /// ObservableCounter is an Instrument which reports monotonically increasing value(s) when the instrument is being observed.
         /// </summary>
@@ -122,6 +175,7 @@ public ObservableCounter<T> CreateObservableCounter<T>(string name, Func<Measure
         public ObservableCounter<T> CreateObservableCounter<T>(string name, Func<IEnumerable<Measurement<T>>> observeValues, string? unit = null, string? description = null) where T : struct =>
                                         new ObservableCounter<T>(this, name, observeValues, unit, description);
 
+
         /// <summary>
         /// ObservableGauge is an asynchronous Instrument which reports non-additive value(s) (e.g. the room temperature - it makes no sense to report the temperature value from multiple rooms and sum them up) when the instrument is being observed.
         /// </summary>
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/ObservableUpDownCounter.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/ObservableUpDownCounter.cs
new file mode 100644
index 00000000000000..7751067ac55a32
--- /dev/null
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/ObservableUpDownCounter.cs
@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+
+namespace System.Diagnostics.Metrics
+{
+    /// <summary>
+    /// ObservableUpDownCounter is a metrics observable Instrument which reports increasing or decreasing value(s) when the instrument is being observed.
+    /// e.g. the process heap size or the approximate number of items in a lock-free circular buffer.
+    /// Use Meter.CreateObservableUpDownCounter methods to create an ObservableUpDownCounter object.
+    /// </summary>
+    /// <remarks>
+    /// This class supports only the following generic parameter types: <see cref="byte" />, <see cref="short" />, <see cref="int" />, <see cref="long" />, <see cref="float" />, <see cref="double" />, and <see cref="decimal" />
+    /// </remarks>
+#if ALLOW_PARTIALLY_TRUSTED_CALLERS
+        [System.Security.SecuritySafeCriticalAttribute]
+#endif
+    public sealed class ObservableUpDownCounter<T> : ObservableInstrument<T> where T : struct
+    {
+        private object _callback;
+
+        internal ObservableUpDownCounter(Meter meter, string name, Func<T> observeValue, string? unit, string? description) : base(meter, name, unit, description)
+        {
+            if (observeValue is null)
+            {
+                throw new ArgumentNullException(nameof(observeValue));
+            }
+
+            _callback = observeValue;
+            Publish();
+        }
+
+        internal ObservableUpDownCounter(Meter meter, string name, Func<Measurement<T>> observeValue, string? unit, string? description) : base(meter, name, unit, description)
+        {
+            if (observeValue is null)
+            {
+                throw new ArgumentNullException(nameof(observeValue));
+            }
+
+            _callback = observeValue;
+            Publish();
+        }
+
+        internal ObservableUpDownCounter(Meter meter, string name, Func<IEnumerable<Measurement<T>>> observeValues, string? unit, string? description) : base(meter, name, unit, description)
+        {
+            if (observeValues is null)
+            {
+                throw new ArgumentNullException(nameof(observeValues));
+            }
+
+            _callback = observeValues;
+            Publish();
+        }
+
+        /// <summary>
+        /// Observe() fetches the current measurements being tracked by this observable counter.
+        /// </summary>
+        protected override IEnumerable<Measurement<T>> Observe() => Observe(_callback);
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/UpDownCounter.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/UpDownCounter.cs
new file mode 100644
index 00000000000000..cad80c52c57ee5
--- /dev/null
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/UpDownCounter.cs
@@ -0,0 +1,76 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+
+namespace System.Diagnostics.Metrics
+{
+    /// <summary>
+    /// The UpDownCounter is an instrument that supports reporting positive or negative metric values.
+    /// UpDownCounter may be used in scenarios like reporting the change in active requests or queue size.
+    /// </summary>
+    /// <remarks>
+    /// This class supports only the following generic parameter types: <see cref="byte" />, <see cref="short" />, <see cref="int" />, <see cref="long" />, <see cref="float" />, <see cref="double" />, and <see cref="decimal" />
+    /// </remarks>
+#if ALLOW_PARTIALLY_TRUSTED_CALLERS
+    [System.Security.SecuritySafeCriticalAttribute]
+#endif
+    public sealed class UpDownCounter<T> : Instrument<T> where T : struct
+    {
+        internal UpDownCounter(Meter meter, string name, string? unit, string? description) : base(meter, name, unit, description)
+        {
+            Publish();
+        }
+
+        /// <summary>
+        /// Record the delta value of the measurement. The delta can be positive, negative or zero.
+        /// </summary>
+        /// <param name="delta">The amount to be added which can be positive, negative or zero.</param>
+        public void Add(T delta) => RecordMeasurement(delta);
+
+        /// <summary>
+        /// Record the delta value of the measurement. The delta can be positive, negative or zero.
+        /// </summary>
+        /// <param name="delta">The amount to be added which can be positive, negative or zero.</param>
+        /// <param name="tag">A key-value pair tag associated with the measurement.</param>
+        public void Add(T delta, KeyValuePair<string, object?> tag) => RecordMeasurement(delta, tag);
+
+        /// <summary>
+        /// Record the delta value of the measurement. The delta can be positive, negative or zero.
+        /// </summary>
+        /// <param name="delta">The amount to be added which can be positive, negative or zero.</param>
+        /// <param name="tag1">A first key-value pair tag associated with the measurement.</param>
+        /// <param name="tag2">A second key-value pair tag associated with the measurement.</param>
+        public void Add(T delta, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2) => RecordMeasurement(delta, tag1, tag2);
+
+        /// <summary>
+        /// Record the delta value of the measurement. The delta can be positive, negative or zero.
+        /// </summary>
+        /// <param name="delta">The amount to be added which can be positive, negative or zero.</param>
+        /// <param name="tag1">A first key-value pair tag associated with the measurement.</param>
+        /// <param name="tag2">A second key-value pair tag associated with the measurement.</param>
+        /// <param name="tag3">A third key-value pair tag associated with the measurement.</param>
+        public void Add(T delta, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2, KeyValuePair<string, object?> tag3) => RecordMeasurement(delta, tag1, tag2, tag3);
+
+        /// <summary>
+        /// Record the delta value of the measurement. The delta can be positive, negative or zero.
+        /// </summary>
+        /// <param name="delta">The amount to be added which can be positive, negative or zero.</param>
+        /// <param name="tags">A span of key-value pair tags associated with the measurement.</param>
+        public void Add(T delta, ReadOnlySpan<KeyValuePair<string, object?>> tags) => RecordMeasurement(delta, tags);
+
+        /// <summary>
+        /// Record the delta value of the measurement. The delta can be positive, negative or zero.
+        /// </summary>
+        /// <param name="delta">The amount to be added which can be positive, negative or zero.</param>
+        /// <param name="tags">A list of key-value pair tags associated with the measurement.</param>
+        public void Add(T delta, params KeyValuePair<string, object?>[] tags) => RecordMeasurement(delta, tags.AsSpan());
+
+        /// <summary>
+        /// Record the delta value of the measurement. The delta can be positive, negative or zero.
+        /// </summary>
+        /// <param name="delta">The amount to be added which can be positive, negative or zero.</param>
+        /// <param name="tagList">A <see cref="T:System.Diagnostics.TagList" /> of tags associated with the measurement.</param>
+        public void Add(T delta, in TagList tagList) => RecordMeasurement(delta, in tagList);
+    }
+}
\ No newline at end of file
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs
index c0da50f20431db..929a378dd7f78a 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs
@@ -37,12 +37,18 @@ public void InstrumentCreationTest()
                 Counter<int> counter = meter.CreateCounter<int>("Counter", "seconds", "Seconds Counter");
                 ValidateInstrumentInfo(counter, "Counter", "seconds", "Seconds Counter", false, false);
 
+                UpDownCounter<int> upDownCounter = meter.CreateUpDownCounter<int>("UpDownCounter", "seconds", "Seconds UpDownCounter");
+                ValidateInstrumentInfo(upDownCounter, "UpDownCounter", "seconds", "Seconds UpDownCounter", false, false);
+
                 Histogram<float> histogram = meter.CreateHistogram<float>("Histogram", "centimeters", "centimeters Histogram");
                 ValidateInstrumentInfo(histogram, "Histogram", "centimeters", "centimeters Histogram", false, false);
 
                 ObservableCounter<long> observableCounter = meter.CreateObservableCounter<long>("ObservableCounter", () => 10, "millisecond", "millisecond ObservableCounter");
                 ValidateInstrumentInfo(observableCounter, "ObservableCounter", "millisecond", "millisecond ObservableCounter", false, true);
 
+                ObservableUpDownCounter<long> observableUpDownCounter = meter.CreateObservableUpDownCounter<long>("ObservableUpDownCounter", () => -1, "request", "request ObservableUpDownCounter");
+                ValidateInstrumentInfo(observableUpDownCounter, "ObservableUpDownCounter", "request", "request ObservableUpDownCounter", false, true);
+
                 ObservableGauge<double> observableGauge = meter.CreateObservableGauge<double>("ObservableGauge", () => 10, "Fahrenheit", "Fahrenheit ObservableGauge");
                 ValidateInstrumentInfo(observableGauge, "ObservableGauge", "Fahrenheit", "Fahrenheit ObservableGauge", false, true);
             }).Dispose();
@@ -55,8 +61,10 @@ public void CreateInstrumentParametersTest()
                 Meter meter = new Meter("CreateInstrumentParametersTest");
 
                 Assert.Throws<ArgumentNullException>(() => meter.CreateCounter<byte>(null, "seconds", "Seconds Counter"));
+                Assert.Throws<ArgumentNullException>(() => meter.CreateUpDownCounter<float>(null, "items", "Items UpDownCounter"));
                 Assert.Throws<ArgumentNullException>(() => meter.CreateHistogram<short>(null, "seconds", "Seconds Counter"));
                 Assert.Throws<ArgumentNullException>(() => meter.CreateObservableCounter<long>(null, () => 0, "seconds", "Seconds ObservableCounter"));
+                Assert.Throws<ArgumentNullException>(() => meter.CreateObservableUpDownCounter<Decimal>(null, () => 0, "items", "Items ObservableUpDownCounter"));
                 Assert.Throws<ArgumentNullException>(() => meter.CreateObservableGauge<double>(null, () => 0, "seconds", "Seconds ObservableGauge"));
 
             }).Dispose();
@@ -76,6 +84,14 @@ public void SupportedGenericParameterTypesTest()
                 Counter<double> counter6 = meter.CreateCounter<double>("Counter6", "seconds", "Seconds Counter");
                 Counter<decimal> counter7 = meter.CreateCounter<decimal>("Counter7", "seconds", "Seconds Counter");
 
+                UpDownCounter<byte> upDownCounter1 = meter.CreateUpDownCounter<byte>("UpDownCounter1", "seconds", "Seconds UpDownCounter");
+                UpDownCounter<short> upDownCounter2 = meter.CreateUpDownCounter<short>("UpDownCounter2", "seconds", "Seconds Counter");
+                UpDownCounter<int> upDownCounter3 = meter.CreateUpDownCounter<int>("UpDownCounter3", "seconds", "Seconds UpDownCounter");
+                UpDownCounter<long> upDownCounter4 = meter.CreateUpDownCounter<long>("UpDownCounter4", "seconds", "Seconds UpDownCounter");
+                UpDownCounter<float> upDownCounter5 = meter.CreateUpDownCounter<float>("UpDownCounter5", "seconds", "Seconds UpDownCounter");
+                UpDownCounter<double> upDownCounter6 = meter.CreateUpDownCounter<double>("UpDownCounter6", "seconds", "Seconds UpDownCounter");
+                UpDownCounter<decimal> upDownCounter7 = meter.CreateUpDownCounter<decimal>("UpDownCounter7", "seconds", "Seconds UpDownCounter");
+
                 Histogram<byte> histogram1 = meter.CreateHistogram<byte>("histogram1", "seconds", "Seconds histogram");
                 Histogram<short> histogram2 = meter.CreateHistogram<short>("histogram2", "seconds", "Seconds histogram");
                 Histogram<int> histogram3 = meter.CreateHistogram<int>("histogram3", "seconds", "Seconds histogram");
@@ -92,6 +108,14 @@ public void SupportedGenericParameterTypesTest()
                 ObservableCounter<double> observableCounter6 = meter.CreateObservableCounter<double>("observableCounter6", () => 0, "seconds", "Seconds ObservableCounter");
                 ObservableCounter<decimal> observableCounter7 = meter.CreateObservableCounter<decimal>("observableCounter7", () => 0, "seconds", "Seconds ObservableCounter");
 
+                ObservableUpDownCounter<byte> observableUpDownCounter1 = meter.CreateObservableUpDownCounter<byte>("observableUpDownCounter1", () => 0, "items", "Items ObservableUpDownCounter");
+                ObservableUpDownCounter<short> observableUpDownCounter2 = meter.CreateObservableUpDownCounter<short>("observableUpDownCounter2", () => 0, "items", "Items ObservableCounter");
+                ObservableUpDownCounter<int> observableUpDownCounter3 = meter.CreateObservableUpDownCounter<int>("observableUpDownCounter3", () => 0, "items", "Items ObservableUpDownCounter");
+                ObservableUpDownCounter<long> observableUpDownCounter4 = meter.CreateObservableUpDownCounter<long>("observableUpDownCounter4", () => 0, "items", "Items ObservableUpDownCounter");
+                ObservableUpDownCounter<float> observableUpDownCounter5 = meter.CreateObservableUpDownCounter<float>("observableUpDownCounter5", () => 0, "items", "Items ObservableUpDownCounter");
+                ObservableUpDownCounter<double> observableUpDownCounter6 = meter.CreateObservableUpDownCounter<double>("observableUpDownCounter6", () => 0, "items", "Items ObservableUpDownCounter");
+                ObservableUpDownCounter<decimal> observableUpDownCounter7 = meter.CreateObservableUpDownCounter<decimal>("observableUpDownCounter7", () => 0, "items", "Items ObservableUpDownCounter");
+
                 ObservableGauge<byte> observableGauge1 = meter.CreateObservableGauge<byte>("observableGauge1", () => 0, "seconds", "Seconds ObservableGauge");
                 ObservableGauge<short> observableGauge2 = meter.CreateObservableGauge<short>("observableGauge2", () => 0, "seconds", "Seconds ObservableGauge");
                 ObservableGauge<int> observableGauge3 = meter.CreateObservableGauge<int>("observableGauge3", () => 0, "seconds", "Seconds ObservableGauge");
@@ -101,6 +125,7 @@ public void SupportedGenericParameterTypesTest()
                 ObservableGauge<decimal> observableGauge7 = meter.CreateObservableGauge<decimal>("observableGauge7", () => 0, "seconds", "Seconds ObservableGauge");
 
                 Assert.Throws<InvalidOperationException>(() => meter.CreateCounter<uint>("Counter", "seconds", "Seconds Counter"));
+                Assert.Throws<InvalidOperationException>(() => meter.CreateUpDownCounter<uint>("UpDownCounter", "items", "Items Counter"));
                 Assert.Throws<InvalidOperationException>(() => meter.CreateHistogram<ulong>("histogram1", "seconds", "Seconds histogram"));
                 Assert.Throws<InvalidOperationException>(() => meter.CreateObservableCounter<sbyte>("observableCounter3", () => 0, "seconds", "Seconds ObservableCounter"));
                 Assert.Throws<InvalidOperationException>(() => meter.CreateObservableGauge<ushort>("observableGauge7", () => 0, "seconds", "Seconds ObservableGauge"));
@@ -134,8 +159,10 @@ public void ListeningToInstrumentsPublishingTest()
 
                     Histogram<byte> histogram = meter.CreateHistogram<byte>("histogram1", "seconds", "Seconds histogram");
                     ObservableCounter<byte> observableCounter = meter.CreateObservableCounter<byte>("observableCounter1", () => 0, "seconds", "Seconds ObservableCounter");
+                    UpDownCounter<long> upDownCounter = meter.CreateUpDownCounter<long>("UpDownCounter4", "request", "Requests UpDownCounter");
+                    ObservableUpDownCounter<byte> observableUpDownCounter = meter.CreateObservableUpDownCounter<byte>("observableUpDownCounter1", () => 0, "items", "Items ObservableCounter");
 
-                    Assert.Equal(4, instrumentsEncountered);
+                    Assert.Equal(6, instrumentsEncountered);
 
                     // Enable listening to the 4 instruments
 
@@ -143,6 +170,8 @@ public void ListeningToInstrumentsPublishingTest()
                     listener.EnableMeasurementEvents(observableGauge, observableGauge);
                     listener.EnableMeasurementEvents(histogram, histogram);
                     listener.EnableMeasurementEvents(observableCounter, observableCounter);
+                    listener.EnableMeasurementEvents(upDownCounter, upDownCounter);
+                    listener.EnableMeasurementEvents(observableUpDownCounter, observableUpDownCounter);
 
                     // Enable listening to instruments unpublished event
                     listener.MeasurementsCompleted = (instruments, state) => { instrumentsEncountered--; Assert.Same(state, instruments); };
@@ -169,15 +198,21 @@ public void ThrowingExceptionsFromObservableInstrumentCallbacks()
                     ObservableGauge<int>    gauge1   = meter.CreateObservableGauge<int>("observableGauge1", (Func<int>)(() => throw new ArgumentException()));
                     ObservableCounter<int>  counter2 = meter.CreateObservableCounter<int>("observableCounter2", (Func<int>)(() => throw new PlatformNotSupportedException()));
                     ObservableGauge<int>    gauge2   = meter.CreateObservableGauge<int>("observableGauge2", (Func<int>)(() => throw new NullReferenceException()));
+                    ObservableUpDownCounter<int>  upDownCounterCounter1 = meter.CreateObservableUpDownCounter<int>("upDownCounter1", (Func<int>) (() => throw new ArgumentOutOfRangeException()));
+                    ObservableUpDownCounter<int>  upDownCounterCounter2 = meter.CreateObservableUpDownCounter<int>("upDownCounter2", (Func<int>) (() => throw new PlatformNotSupportedException()));
                     ObservableCounter<int>  counter3 = meter.CreateObservableCounter<int>("observableCounter3", () => 5);
                     ObservableGauge<int>    gauge3   = meter.CreateObservableGauge<int>("observableGauge3", () => 7);
+                    ObservableUpDownCounter<int>  upDownCounterCounter3 = meter.CreateObservableUpDownCounter<int>("ObservableUpDownCounter3", () => -1);
 
                     listener.EnableMeasurementEvents(counter1, null);
                     listener.EnableMeasurementEvents(gauge1, null);
                     listener.EnableMeasurementEvents(counter2, null);
                     listener.EnableMeasurementEvents(gauge2, null);
+                    listener.EnableMeasurementEvents(upDownCounterCounter1, null);
+                    listener.EnableMeasurementEvents(upDownCounterCounter2, null);
                     listener.EnableMeasurementEvents(counter3, null);
                     listener.EnableMeasurementEvents(gauge3, null);
+                    listener.EnableMeasurementEvents(upDownCounterCounter3, null);
 
                     int accumulated = 0;
 
@@ -187,15 +222,17 @@ public void ThrowingExceptionsFromObservableInstrumentCallbacks()
                     Assert.NotNull(exception);
                     Assert.IsType<AggregateException>(exception);
                     AggregateException ae = exception as AggregateException;
-                    Assert.Equal(4, ae.InnerExceptions.Count);
+                    Assert.Equal(6, ae.InnerExceptions.Count);
 
                     Assert.IsType<ArgumentOutOfRangeException>(ae.InnerExceptions[0]);
                     Assert.IsType<ArgumentException>(ae.InnerExceptions[1]);
                     Assert.IsType<PlatformNotSupportedException>(ae.InnerExceptions[2]);
                     Assert.IsType<NullReferenceException>(ae.InnerExceptions[3]);
+                    Assert.IsType<ArgumentOutOfRangeException>(ae.InnerExceptions[4]);
+                    Assert.IsType<PlatformNotSupportedException>(ae.InnerExceptions[5]);
 
                     // Ensure the instruments which didn't throw reported correct measurements.
-                    Assert.Equal(12, accumulated);
+                    Assert.Equal(11, accumulated);
                 }
 
             }).Dispose();
@@ -208,46 +245,67 @@ public void InstrumentMeasurementTest()
                 Meter meter = new Meter("InstrumentMeasurementTest");
 
                 Counter<byte> counter = meter.CreateCounter<byte>("byteCounter");
-                InstruementMeasurementAggregationValidation(counter, (value, tags) => { counter.Add(value, tags); } );
+                InstrumentMeasurementAggregationValidation(counter, (value, tags) => { counter.Add(value, tags); } );
+
+                UpDownCounter<byte> upDownCounter = meter.CreateUpDownCounter<byte>("byteUpDownCounter");
+                InstrumentMeasurementAggregationValidation(upDownCounter, (value, tags) => { upDownCounter.Add(value, tags); });
 
                 Counter<short> counter1 = meter.CreateCounter<short>("shortCounter");
-                InstruementMeasurementAggregationValidation(counter1, (value, tags) => { counter1.Add(value, tags); } );
+                InstrumentMeasurementAggregationValidation(counter1, (value, tags) => { counter1.Add(value, tags); } );
+
+                UpDownCounter<short> upDownCounter1 = meter.CreateUpDownCounter<short>("shortUpDownCounter");
+                InstrumentMeasurementAggregationValidation(upDownCounter1, (value, tags) => { upDownCounter1.Add(value, tags); }, true);
 
                 Counter<int> counter2 = meter.CreateCounter<int>("intCounter");
-                InstruementMeasurementAggregationValidation(counter2, (value, tags) => { counter2.Add(value, tags); } );
+                InstrumentMeasurementAggregationValidation(counter2, (value, tags) => { counter2.Add(value, tags); } );
+
+                UpDownCounter<int> upDownCounter2 = meter.CreateUpDownCounter<int>("intUpDownCounter");
+                InstrumentMeasurementAggregationValidation(upDownCounter2, (value, tags) => { upDownCounter2.Add(value, tags); }, true);
 
                 Counter<long> counter3 = meter.CreateCounter<long>("longCounter");
-                InstruementMeasurementAggregationValidation(counter3, (value, tags) => { counter3.Add(value, tags); } );
+                InstrumentMeasurementAggregationValidation(counter3, (value, tags) => { counter3.Add(value, tags); } );
+
+                UpDownCounter<long> upDownCounter3 = meter.CreateUpDownCounter<long>("longUpDownCounter");
+                InstrumentMeasurementAggregationValidation(upDownCounter3, (value, tags) => { upDownCounter3.Add(value, tags); }, true);
 
                 Counter<float> counter4 = meter.CreateCounter<float>("floatCounter");
-                InstruementMeasurementAggregationValidation(counter4, (value, tags) => { counter4.Add(value, tags); } );
+                InstrumentMeasurementAggregationValidation(counter4, (value, tags) => { counter4.Add(value, tags); } );
+
+                UpDownCounter<float> upDownCounter4 = meter.CreateUpDownCounter<float>("floatUpDownCounter");
+                InstrumentMeasurementAggregationValidation(upDownCounter4, (value, tags) => { upDownCounter4.Add(value, tags); }, true);
 
                 Counter<double> counter5 = meter.CreateCounter<double>("doubleCounter");
-                InstruementMeasurementAggregationValidation(counter5, (value, tags) => { counter5.Add(value, tags); } );
+                InstrumentMeasurementAggregationValidation(counter5, (value, tags) => { counter5.Add(value, tags); } );
+
+                UpDownCounter<double> upDownCounter5 = meter.CreateUpDownCounter<double>("doubleUpDownCounter");
+                InstrumentMeasurementAggregationValidation(upDownCounter5, (value, tags) => { upDownCounter5.Add(value, tags); }, true);
 
                 Counter<decimal> counter6 = meter.CreateCounter<decimal>("decimalCounter");
-                InstruementMeasurementAggregationValidation(counter6, (value, tags) => { counter6.Add(value, tags); } );
+                InstrumentMeasurementAggregationValidation(counter6, (value, tags) => { counter6.Add(value, tags); } );
+
+                UpDownCounter<decimal> upDownCounter6 = meter.CreateUpDownCounter<decimal>("decimalUpDownCounter");
+                InstrumentMeasurementAggregationValidation(upDownCounter6, (value, tags) => { upDownCounter6.Add(value, tags); }, true);
 
                 Histogram<byte> histogram = meter.CreateHistogram<byte>("byteHistogram");
-                InstruementMeasurementAggregationValidation(histogram, (value, tags) => { histogram.Record(value, tags); } );
+                InstrumentMeasurementAggregationValidation(histogram, (value, tags) => { histogram.Record(value, tags); } );
 
                 Histogram<short> histogram1 = meter.CreateHistogram<short>("shortHistogram");
-                InstruementMeasurementAggregationValidation(histogram1, (value, tags) => { histogram1.Record(value, tags); } );
+                InstrumentMeasurementAggregationValidation(histogram1, (value, tags) => { histogram1.Record(value, tags); } );
 
                 Histogram<int> histogram2 = meter.CreateHistogram<int>("intHistogram");
-                InstruementMeasurementAggregationValidation(histogram2, (value, tags) => { histogram2.Record(value, tags); } );
+                InstrumentMeasurementAggregationValidation(histogram2, (value, tags) => { histogram2.Record(value, tags); } );
 
                 Histogram<long> histogram3 = meter.CreateHistogram<long>("longHistogram");
-                InstruementMeasurementAggregationValidation(histogram3, (value, tags) => { histogram3.Record(value, tags); } );
+                InstrumentMeasurementAggregationValidation(histogram3, (value, tags) => { histogram3.Record(value, tags); } );
 
                 Histogram<float> histogram4 = meter.CreateHistogram<float>("floatHistogram");
-                InstruementMeasurementAggregationValidation(histogram4, (value, tags) => { histogram4.Record(value, tags); } );
+                InstrumentMeasurementAggregationValidation(histogram4, (value, tags) => { histogram4.Record(value, tags); } );
 
                 Histogram<double> histogram5 = meter.CreateHistogram<double>("doubleHistogram");
-                InstruementMeasurementAggregationValidation(histogram5, (value, tags) => { histogram5.Record(value, tags); } );
+                InstrumentMeasurementAggregationValidation(histogram5, (value, tags) => { histogram5.Record(value, tags); } );
 
                 Histogram<decimal> histogram6 = meter.CreateHistogram<decimal>("decimalHistogram");
-                InstruementMeasurementAggregationValidation(histogram6, (value, tags) => { histogram6.Record(value, tags); } );
+                InstrumentMeasurementAggregationValidation(histogram6, (value, tags) => { histogram6.Record(value, tags); } );
 
             }).Dispose();
         }
@@ -263,99 +321,148 @@ public void ObservableInstrumentMeasurementTest()
                 // CreateObservableCounter using Func<T>
                 //
                 ObservableCounter<byte> observableCounter = meter.CreateObservableCounter<byte>("ByteObservableCounter", () => 50);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter, new Measurement<byte>[] { new Measurement<byte>(50)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter, new Measurement<byte>[] { new Measurement<byte>(50)});
                 ObservableCounter<short> observableCounter1 = meter.CreateObservableCounter<short>("ShortObservableCounter", () => 30_000);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter1, new Measurement<short>[] { new Measurement<short>(30_000)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter1, new Measurement<short>[] { new Measurement<short>(30_000)});
                 ObservableCounter<int> observableCounter2 = meter.CreateObservableCounter<int>("IntObservableCounter", () => 1_000_000);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter2, new Measurement<int>[] { new Measurement<int>(1_000_000)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter2, new Measurement<int>[] { new Measurement<int>(1_000_000)});
                 ObservableCounter<long> observableCounter3 = meter.CreateObservableCounter<long>("longObservableCounter", () => 1_000_000_000);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter3, new Measurement<long>[] { new Measurement<long>(1_000_000_000)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter3, new Measurement<long>[] { new Measurement<long>(1_000_000_000)});
                 ObservableCounter<float> observableCounter4 = meter.CreateObservableCounter<float>("floatObservableCounter", () => 3.14f);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter4, new Measurement<float>[] { new Measurement<float>(3.14f)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter4, new Measurement<float>[] { new Measurement<float>(3.14f)});
                 ObservableCounter<double> observableCounter5 = meter.CreateObservableCounter<double>("doubleObservableCounter", () => 1e6);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter5, new Measurement<double>[] { new Measurement<double>(1e6)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter5, new Measurement<double>[] { new Measurement<double>(1e6)});
                 ObservableCounter<decimal> observableCounter6 = meter.CreateObservableCounter<decimal>("decimalObservableCounter", () => 1.5E6m);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter6, new Measurement<decimal>[] { new Measurement<decimal>(1.5E6m)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter6, new Measurement<decimal>[] { new Measurement<decimal>(1.5E6m)});
+
+                //
+                // CreateObservableUpDownCounter using Func<T>
+                //
+                ObservableUpDownCounter<byte> observableUpDownCounter = meter.CreateObservableUpDownCounter<byte>("ByteObservableUpDownCounter", () => 10);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter, new Measurement<byte>[] { new Measurement<byte>(10)});
+                ObservableUpDownCounter<short> observableUpDownCounter1 = meter.CreateObservableUpDownCounter<short>("shortObservableUpDownCounter", () => -10);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter1, new Measurement<short>[] { new Measurement<short>(-10)});
+                ObservableUpDownCounter<int> observableUpDownCounter2 = meter.CreateObservableUpDownCounter<int>("intObservableUpDownCounter", () => -12);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter2, new Measurement<int>[] { new Measurement<int>(-12)});
+                ObservableUpDownCounter<long> observableUpDownCounter3 = meter.CreateObservableUpDownCounter<long>("longObservableUpDownCounter", () => -100);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter3, new Measurement<long>[] { new Measurement<long>(-100)});
+                ObservableUpDownCounter<float> observableUpDownCounter4 = meter.CreateObservableUpDownCounter<float>("floatObservableUpDownCounter", () => -3.4f);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter4, new Measurement<float>[] { new Measurement<float>(-3.4f)});
+                ObservableUpDownCounter<double> observableUpDownCounter5 = meter.CreateObservableUpDownCounter<double>("doubleObservableUpDownCounter", () => -3.14);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter5, new Measurement<double>[] { new Measurement<double>(-3.14)});
+                ObservableUpDownCounter<decimal> observableUpDownCounter6 = meter.CreateObservableUpDownCounter<decimal>("doubleObservableUpDownCounter", () => -32222.14m);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter6, new Measurement<decimal>[] { new Measurement<decimal>(-32222.14m)});
 
                 //
                 // CreateObservableGauge using Func<T>
                 //
                 ObservableGauge<byte> observableGauge = meter.CreateObservableGauge<byte>("ByteObservableGauge", () => 100);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge, new Measurement<byte>[] { new Measurement<byte>(100)});
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge, new Measurement<byte>[] { new Measurement<byte>(100)});
                 ObservableGauge<short> observableGauge1 = meter.CreateObservableGauge<short>("ShortObservableGauge", () => 30_123);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge1, new Measurement<short>[] { new Measurement<short>(30_123)});
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge1, new Measurement<short>[] { new Measurement<short>(30_123)});
                 ObservableGauge<int> observableGauge2 = meter.CreateObservableGauge<int>("IntObservableGauge", () => 2_123_456);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge2, new Measurement<int>[] { new Measurement<int>(2_123_456)});
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge2, new Measurement<int>[] { new Measurement<int>(2_123_456)});
                 ObservableGauge<long> observableGauge3 = meter.CreateObservableGauge<long>("longObservableGauge", () => 3_123_456_789);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge3, new Measurement<long>[] { new Measurement<long>(3_123_456_789)});
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge3, new Measurement<long>[] { new Measurement<long>(3_123_456_789)});
                 ObservableGauge<float> observableGauge4 = meter.CreateObservableGauge<float>("floatObservableGauge", () => 1.6f);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge4, new Measurement<float>[] { new Measurement<float>(1.6f)});
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge4, new Measurement<float>[] { new Measurement<float>(1.6f)});
                 ObservableGauge<double> observableGauge5 = meter.CreateObservableGauge<double>("doubleObservableGauge", () => 1e5);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge5, new Measurement<double>[] { new Measurement<double>(1e5)});
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge5, new Measurement<double>[] { new Measurement<double>(1e5)});
                 ObservableGauge<decimal> observableGauge6 = meter.CreateObservableGauge<decimal>("decimalObservableGauge", () => 2.5E7m);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge6, new Measurement<decimal>[] { new Measurement<decimal>(2.5E7m)});
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge6, new Measurement<decimal>[] { new Measurement<decimal>(2.5E7m)});
 
                 //
                 // CreateObservableCounter using Func<Measurement<T>>
                 //
                 Measurement<byte> byteMeasurement = new Measurement<byte>(60, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T1", "V1"), new KeyValuePair<string, object?>("T2", "V2") });
                 ObservableCounter<byte> observableCounter7 = meter.CreateObservableCounter<byte>("ByteObservableCounter", () => byteMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter7, new Measurement<byte>[] { byteMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter7, new Measurement<byte>[] { byteMeasurement });
 
                 Measurement<short> shortMeasurement = new Measurement<short>(20_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T3", "V3"), new KeyValuePair<string, object?>("T4", "V4") });
                 ObservableCounter<short> observableCounter8 = meter.CreateObservableCounter<short>("ShortObservableCounter", () => shortMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter8, new Measurement<short>[] { shortMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter8, new Measurement<short>[] { shortMeasurement });
 
                 Measurement<int> intMeasurement = new Measurement<int>(2_000_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T5", "V5"), new KeyValuePair<string, object?>("T6", "V6") });
                 ObservableCounter<int> observableCounter9 = meter.CreateObservableCounter<int>("IntObservableCounter", () => intMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter9, new Measurement<int>[] { intMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter9, new Measurement<int>[] { intMeasurement });
 
                 Measurement<long> longMeasurement = new Measurement<long>(20_000_000_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T7", "V7"), new KeyValuePair<string, object?>("T8", "V8") });
                 ObservableCounter<long> observableCounter10 = meter.CreateObservableCounter<long>("longObservableCounter", () => longMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter10, new Measurement<long>[] { longMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter10, new Measurement<long>[] { longMeasurement });
 
                 Measurement<float> floatMeasurement = new Measurement<float>(1e2f, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T9", "V10"), new KeyValuePair<string, object?>("T11", "V12") });
                 ObservableCounter<float> observableCounter11 = meter.CreateObservableCounter<float>("floatObservableCounter", () => 3.14f);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter11, new Measurement<float>[] { new Measurement<float>(3.14f)});
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter11, new Measurement<float>[] { new Measurement<float>(3.14f)});
 
                 Measurement<double> doubleMeasurement = new Measurement<double>(2.5e7, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T13", "V14"), new KeyValuePair<string, object?>("T15", "V16") });
                 ObservableCounter<double> observableCounter12 = meter.CreateObservableCounter<double>("doubleObservableCounter", () => doubleMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter12, new Measurement<double>[] { doubleMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter12, new Measurement<double>[] { doubleMeasurement });
 
                 Measurement<decimal> decimalMeasurement = new Measurement<decimal>(3.2e20m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T17", "V18"), new KeyValuePair<string, object?>("T19", "V20") });
                 ObservableCounter<decimal> observableCounter13 = meter.CreateObservableCounter<decimal>("decimalObservableCounter", () => decimalMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter13, new Measurement<decimal>[] { decimalMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter13, new Measurement<decimal>[] { decimalMeasurement });
+
+                //
+                // CreateObservableUpDownCounter using Func<Measurement<T>>
+                //
+                Measurement<byte> byteMeasurement1 = new Measurement<byte>(100, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T1", "V1"), new KeyValuePair<string, object?>("T2", "V2") });
+                ObservableUpDownCounter<byte> observableUpDownCounter7 = meter.CreateObservableUpDownCounter<byte>("ByteObservableUpDownCounter", () => byteMeasurement1);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter7, new Measurement<byte>[] { byteMeasurement1 });
+
+                Measurement<short> shortMeasurement1 = new Measurement<short>(-20_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T3", "V3"), new KeyValuePair<string, object?>("T4", "V4") });
+                ObservableUpDownCounter<short> observableUpDownCounter8 = meter.CreateObservableUpDownCounter<short>("ShortObservableUpDownCounter", () => shortMeasurement1);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter8, new Measurement<short>[] { shortMeasurement1 });
+
+                Measurement<int> intMeasurement1 = new Measurement<int>(-2_000_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T5", "V5"), new KeyValuePair<string, object?>("T6", "V6") });
+                ObservableUpDownCounter<int> observableUpDownCounter9 = meter.CreateObservableUpDownCounter<int>("IntObservableUpDownCounter", () => intMeasurement1);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter9, new Measurement<int>[] { intMeasurement1 });
+
+                Measurement<long> longMeasurement1 = new Measurement<long>(-20_000_000_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T7", "V7"), new KeyValuePair<string, object?>("T8", "V8") });
+                ObservableUpDownCounter<long> observableUpDownCounter10 = meter.CreateObservableUpDownCounter<long>("longObservableUpDownCounter", () => longMeasurement1);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter10, new Measurement<long>[] { longMeasurement1 });
+
+                Measurement<float> floatMeasurement1 = new Measurement<float>(-1e2f, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T9", "V10"), new KeyValuePair<string, object?>("T11", "V12") });
+                ObservableUpDownCounter<float> observableUpDownCounter11 = meter.CreateObservableUpDownCounter<float>("floatObservableUpDownCounter", () => floatMeasurement1);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter11, new Measurement<float>[] { floatMeasurement1 });
+
+                Measurement<double> doubleMeasurement1 = new Measurement<double>(-2.5e7, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T13", "V14"), new KeyValuePair<string, object?>("T15", "V16") });
+                ObservableUpDownCounter<double> observableUpDownCounter12 = meter.CreateObservableUpDownCounter<double>("doubleObservableUpDownCounter", () => doubleMeasurement1);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter12, new Measurement<double>[] { doubleMeasurement1 });
+
+                Measurement<decimal> decimalMeasurement1 = new Measurement<decimal>(-3.2e20m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T17", "V18"), new KeyValuePair<string, object?>("T19", "V20") });
+                ObservableUpDownCounter<decimal> observableUpDownCounter13 = meter.CreateObservableUpDownCounter<decimal>("decimalObservableUpDownCounter", () => decimalMeasurement1);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter13, new Measurement<decimal>[] { decimalMeasurement1 });
 
                 //
                 // CreateObservableGauge using Func<Measurement<T>>
                 //
                 Measurement<byte> byteGaugeMeasurement = new Measurement<byte>(35, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T21", "V22"), new KeyValuePair<string, object?>("T23", "V24") });
                 ObservableGauge<byte> observableGauge7 = meter.CreateObservableGauge<byte>("ByteObservableGauge", () => byteGaugeMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge7, new Measurement<byte>[] { byteGaugeMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge7, new Measurement<byte>[] { byteGaugeMeasurement });
 
                 Measurement<short> shortGaugeMeasurement = new Measurement<short>(23_987, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T25", "V26"), new KeyValuePair<string, object?>("T27", "V28") });
                 ObservableGauge<short> observableGauge8 = meter.CreateObservableGauge<short>("ShortObservableGauge", () => shortGaugeMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge8, new Measurement<short>[] { shortGaugeMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge8, new Measurement<short>[] { shortGaugeMeasurement });
 
                 Measurement<int> intGaugeMeasurement = new Measurement<int>(1_987_765, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T29", "V30"), new KeyValuePair<string, object?>("T31", "V32") });
                 ObservableGauge<int> observableGauge9 = meter.CreateObservableGauge<int>("IntObservableGauge", () => intGaugeMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge9, new Measurement<int>[] { intGaugeMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge9, new Measurement<int>[] { intGaugeMeasurement });
 
                 Measurement<long> longGaugeMeasurement = new Measurement<long>(10_000_234_343, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T33", "V342"), new KeyValuePair<string, object?>("T35", "V36") });
                 ObservableGauge<long> observableGauge10 = meter.CreateObservableGauge<long>("longObservableGauge", () => longGaugeMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge10, new Measurement<long>[] { longGaugeMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge10, new Measurement<long>[] { longGaugeMeasurement });
 
                 Measurement<float> floatGaugeMeasurement = new Measurement<float>(2.1f, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T37", "V38"), new KeyValuePair<string, object?>("T39", "V40") });
                 ObservableGauge<float> observableGauge11 = meter.CreateObservableGauge<float>("floatObservableGauge", () => floatGaugeMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge11, new Measurement<float>[] { floatGaugeMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge11, new Measurement<float>[] { floatGaugeMeasurement });
 
                 Measurement<double> doubleGaugeMeasurement = new Measurement<double>(1.5e30, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T41", "V42"), new KeyValuePair<string, object?>("T43", "V44") });
                 ObservableGauge<double> observableGauge12 = meter.CreateObservableGauge<double>("doubleObservableGauge", () => doubleGaugeMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge12, new Measurement<double>[] { doubleGaugeMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge12, new Measurement<double>[] { doubleGaugeMeasurement });
 
                 Measurement<decimal> decimalGaugeMeasurement = new Measurement<decimal>(2.5e20m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T45", "V46"), new KeyValuePair<string, object?>("T47", "V48") });
                 ObservableGauge<decimal> observableGauge13 = meter.CreateObservableGauge<decimal>("decimalObservableGauge", () => decimalGaugeMeasurement);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge13, new Measurement<decimal>[] { decimalGaugeMeasurement });
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge13, new Measurement<decimal>[] { decimalGaugeMeasurement });
 
                 //
                 // CreateObservableCounter using Func<Measurement<T>>
@@ -366,7 +473,7 @@ public void ObservableInstrumentMeasurementTest()
                     new Measurement<byte>(1, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T51", "V52"), new KeyValuePair<string, object?>("T53", "V54") }),
                 };
                 ObservableCounter<byte> observableCounter14 = meter.CreateObservableCounter<byte>("ByteObservableCounter", () => byteGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter14, byteGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter14, byteGaugeMeasurementList);
 
                 Measurement<short>[] shortGaugeMeasurementList = new Measurement<short>[]
                 {
@@ -374,7 +481,7 @@ public void ObservableInstrumentMeasurementTest()
                     new Measurement<short>(30_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T59", "V60"), new KeyValuePair<string, object?>("T61", "V62") }),
                 };
                 ObservableCounter<short> observableCounter15 = meter.CreateObservableCounter<short>("ShortObservableCounter", () => shortGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter15, shortGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter15, shortGaugeMeasurementList);
 
                 Measurement<int>[] intGaugeMeasurementList = new Measurement<int>[]
                 {
@@ -382,7 +489,7 @@ public void ObservableInstrumentMeasurementTest()
                     new Measurement<int>(1_000_002, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T67", "V68"), new KeyValuePair<string, object?>("T69", "V70") }),
                 };
                 ObservableCounter<int> observableCounter16 = meter.CreateObservableCounter<int>("IntObservableCounter", () => intGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter16, intGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter16, intGaugeMeasurementList);
 
                 Measurement<long>[] longGaugeMeasurementList = new Measurement<long>[]
                 {
@@ -390,7 +497,7 @@ public void ObservableInstrumentMeasurementTest()
                     new Measurement<long>(1_000_002_002, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T75", "V76"), new KeyValuePair<string, object?>("T77", "V78") }),
                 };
                 ObservableCounter<long> observableCounter17 = meter.CreateObservableCounter<long>("longObservableCounter", () => longGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter17, longGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter17, longGaugeMeasurementList);
 
                 Measurement<float>[] floatGaugeMeasurementList = new Measurement<float>[]
                 {
@@ -398,7 +505,7 @@ public void ObservableInstrumentMeasurementTest()
                     new Measurement<float>(68.15e6f, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T83", "V84"), new KeyValuePair<string, object?>("T85", "V86") }),
                 };
                 ObservableCounter<float> observableCounter18 = meter.CreateObservableCounter<float>("floatObservableCounter", () => floatGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter18, floatGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter18, floatGaugeMeasurementList);
 
                 Measurement<double>[] doubleGaugeMeasurementList = new Measurement<double>[]
                 {
@@ -406,7 +513,7 @@ public void ObservableInstrumentMeasurementTest()
                     new Measurement<double>(68.15e21, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T91", "V92"), new KeyValuePair<string, object?>("T93", "V94") }),
                 };
                 ObservableCounter<double> observableCounter19 = meter.CreateObservableCounter<double>("doubleObservableCounter", () => doubleGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter19, doubleGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter19, doubleGaugeMeasurementList);
 
                 Measurement<decimal>[] decimalGaugeMeasurementList = new Measurement<decimal>[]
                 {
@@ -414,31 +521,90 @@ public void ObservableInstrumentMeasurementTest()
                     new Measurement<decimal>(68.15e6m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T99", "V100"), new KeyValuePair<string, object?>("T101", "V102") }),
                 };
                 ObservableCounter<decimal> observableCounter20 = meter.CreateObservableCounter<decimal>("decimalObservableCounter", () => decimalGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableCounter20, decimalGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableCounter20, decimalGaugeMeasurementList);
+
+                //
+                // CreateObservableUpDownCounter using Func<Measurement<T>>
+                //
+                Measurement<byte>[] byteUpDownCounterMeasurementList = new Measurement<byte>[]
+                {
+                    new Measurement<byte>(10, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T48", "V49"), new KeyValuePair<string, object?>("T50", "V51") }),
+                    new Measurement<byte>(12, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T51", "V52"), new KeyValuePair<string, object?>("T53", "V54") }),
+                };
+                ObservableUpDownCounter<byte> observableUpDownCounter14 = meter.CreateObservableUpDownCounter<byte>("ByteObservableUpDownCounter", () => byteUpDownCounterMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter14, byteUpDownCounterMeasurementList);
+
+                Measurement<short>[] shortUpDownCounterMeasurementList = new Measurement<short>[]
+                {
+                    new Measurement<short>(-20_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T55", "V56"), new KeyValuePair<string, object?>("T57", "V58") }),
+                    new Measurement<short>(30_000, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T59", "V60"), new KeyValuePair<string, object?>("T61", "V62") }),
+                };
+                ObservableUpDownCounter<short> observableUpDownCounter15 = meter.CreateObservableUpDownCounter<short>("ShortObservableUpDownCounter", () => shortUpDownCounterMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter15, shortUpDownCounterMeasurementList);
+
+                Measurement<int>[] intUpDownCounterMeasurementList = new Measurement<int>[]
+                {
+                    new Measurement<int>(1_000_001, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T63", "V64"), new KeyValuePair<string, object?>("T65", "V66") }),
+                    new Measurement<int>(-1_000_002, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T67", "V68"), new KeyValuePair<string, object?>("T69", "V70") }),
+                };
+                ObservableUpDownCounter<int> observableUpDownCounter16 = meter.CreateObservableUpDownCounter<int>("IntObservableUpDownCounter", () => intUpDownCounterMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter16, intUpDownCounterMeasurementList);
+
+                Measurement<long>[] longUpDownCounterMeasurementList = new Measurement<long>[]
+                {
+                    new Measurement<long>(-1_000_001_001, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T71", "V72"), new KeyValuePair<string, object?>("T73", "V74") }),
+                    new Measurement<long>(1_000_002_002, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T75", "V76"), new KeyValuePair<string, object?>("T77", "V78") }),
+                };
+                ObservableUpDownCounter<long> observableUpDownCounter17 = meter.CreateObservableUpDownCounter<long>("longObservableUpDownCounter", () => longUpDownCounterMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter17, longUpDownCounterMeasurementList);
+
+                Measurement<float>[] floatUpDownCounterMeasurementList = new Measurement<float>[]
+                {
+                    new Measurement<float>(-68.15e8f, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T79", "V80"), new KeyValuePair<string, object?>("T81", "V82") }),
+                    new Measurement<float>(-68.15e6f, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T83", "V84"), new KeyValuePair<string, object?>("T85", "V86") }),
+                };
+                ObservableUpDownCounter<float> observableUpDownCounter18 = meter.CreateObservableUpDownCounter<float>("floatObservableUpDownCounter", () => floatUpDownCounterMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter18, floatUpDownCounterMeasurementList);
+
+                Measurement<double>[] doubleUpDownCounterMeasurementList = new Measurement<double>[]
+                {
+                    new Measurement<double>(-68.15e20, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T87", "V88"), new KeyValuePair<string, object?>("T89", "V90") }),
+                    new Measurement<double>(68.15e21, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T91", "V92"), new KeyValuePair<string, object?>("T93", "V94") }),
+                };
+                ObservableUpDownCounter<double> observableUpDownCounter19 = meter.CreateObservableUpDownCounter<double>("doubleObservableUpDownCounter", () => doubleUpDownCounterMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter19, doubleUpDownCounterMeasurementList);
+
+                Measurement<decimal>[] decimalUpDownCounterMeasurementList = new Measurement<decimal>[]
+                {
+                    new Measurement<decimal>(68.15e8m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T95", "V96"), new KeyValuePair<string, object?>("T97", "V98") }),
+                    new Measurement<decimal>(-68.15e6m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("T99", "V100"), new KeyValuePair<string, object?>("T101", "V102") }),
+                };
+                ObservableUpDownCounter<decimal> observableUpDownCounter20 = meter.CreateObservableUpDownCounter<decimal>("decimalObservableUpDownCounter", () => decimalUpDownCounterMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableUpDownCounter20, decimalUpDownCounterMeasurementList);
 
                 //
                 // CreateObservableGauge using IEnumerable<Measurement<T>>
                 //
                 ObservableGauge<byte> observableGauge14 = meter.CreateObservableGauge<byte>("ByteObservableGauge", () => byteGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge14, byteGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge14, byteGaugeMeasurementList);
 
                 ObservableGauge<short> observableGauge15 = meter.CreateObservableGauge<short>("ShortObservableGauge", () => shortGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge15, shortGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge15, shortGaugeMeasurementList);
 
                 ObservableGauge<int> observableGauge16 = meter.CreateObservableGauge<int>("IntObservableGauge", () => intGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge16, intGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge16, intGaugeMeasurementList);
 
                 ObservableGauge<long> observableGauge17 = meter.CreateObservableGauge<long>("longObservableGauge", () => longGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge17, longGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge17, longGaugeMeasurementList);
 
                 ObservableGauge<float> observableGauge18 = meter.CreateObservableGauge<float>("floatObservableGauge", () => floatGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge18, floatGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge18, floatGaugeMeasurementList);
 
                 ObservableGauge<double> observableGauge19 = meter.CreateObservableGauge<double>("doubleObservableGauge", () => doubleGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge19, doubleGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge19, doubleGaugeMeasurementList);
 
                 ObservableGauge<decimal> observableGauge20 = meter.CreateObservableGauge<decimal>("decimalObservableGauge", () => decimalGaugeMeasurementList);
-                ObservableInstruementMeasurementAggregationValidation(observableGauge20, decimalGaugeMeasurementList);
+                ObservableInstrumentMeasurementAggregationValidation(observableGauge20, decimalGaugeMeasurementList);
 
             }).Dispose();
         }
@@ -485,6 +651,42 @@ public void PassingVariableTagsParametersTest()
                                                             return (decimal)(value * 2);
                                                         });
 
+                InstrumentPassingVariableTagsParametersTest<byte>(meter.CreateUpDownCounter<byte>("Counter"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishUpDownCounterMeasurement(instrument as UpDownCounter<byte>, value, tags);
+                                                            return (byte)(value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<short>(meter.CreateUpDownCounter<short>("Counter"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishUpDownCounterMeasurement(instrument as UpDownCounter<short>, value, tags);
+                                                            return (short)(-value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<int>(meter.CreateUpDownCounter<int>("Counter"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishUpDownCounterMeasurement(instrument as UpDownCounter<int>, value, tags);
+                                                            return (int)(-value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<long>(meter.CreateUpDownCounter<long>("Counter"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishUpDownCounterMeasurement(instrument as UpDownCounter<long>, value, tags);
+                                                            return (long)(-value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<float>(meter.CreateUpDownCounter<float>("Counter"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishUpDownCounterMeasurement(instrument as UpDownCounter<float>, value, tags);
+                                                            return (float)(-value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<double>(meter.CreateUpDownCounter<double>("Counter"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishUpDownCounterMeasurement(instrument as UpDownCounter<double>, value, tags);
+                                                            return (double)(-value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<decimal>(meter.CreateUpDownCounter<decimal>("Counter"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishUpDownCounterMeasurement(instrument as UpDownCounter<decimal>, value, tags);
+                                                            return (decimal)(-value * 2);
+                                                        });
+
                 InstrumentPassingVariableTagsParametersTest<byte>(meter.CreateHistogram<byte>("Histogram"), (instrument, value, tags) =>
                                                         {
                                                             PublishHistogramMeasurement(instrument as Histogram<byte>, value, tags);
@@ -531,11 +733,15 @@ public void MeterDisposalsTest()
                 Meter meter2 = new Meter("MeterDisposalsTest2");
                 Meter meter3 = new Meter("MeterDisposalsTest3");
                 Meter meter4 = new Meter("MeterDisposalsTest4");
+                Meter meter5 = new Meter("MeterDisposalsTest5");
+                Meter meter6 = new Meter("MeterDisposalsTest6");
 
                 Counter<int> counter = meter1.CreateCounter<int>("Counter");
                 Histogram<double> histogram = meter2.CreateHistogram<double>("Histogram");
                 ObservableCounter<long> observableCounter = meter3.CreateObservableCounter<long>("ObservableCounter", () => new Measurement<long>(10, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
                 ObservableGauge<decimal> observableGauge = meter4.CreateObservableGauge<decimal>("ObservableGauge", () => new Measurement<decimal>(5.7m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
+                UpDownCounter<short> upDownCounter = meter5.CreateUpDownCounter<short>("UpDownCounter");
+                ObservableUpDownCounter<int> observableUpDownCounter = meter6.CreateObservableUpDownCounter<int>("ObservableUpDownCounter", () => new Measurement<int>(-5, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
 
                 using MeterListener listener = new MeterListener();
                 listener.InstrumentPublished = (theInstrument, theListener) => theListener.EnableMeasurementEvents(theInstrument, theInstrument);
@@ -543,6 +749,7 @@ public void MeterDisposalsTest()
                 int count = 0;
 
                 listener.SetMeasurementEventCallback<int>((inst, measurement, tags, state)     => count++);
+                listener.SetMeasurementEventCallback<short>((inst, measurement, tags, state)   => count++);
                 listener.SetMeasurementEventCallback<double>((inst, measurement, tags, state)  => count++);
                 listener.SetMeasurementEventCallback<long>((inst, measurement, tags, state)    => count++);
                 listener.SetMeasurementEventCallback<decimal>((inst, measurement, tags, state) => count++);
@@ -554,30 +761,41 @@ public void MeterDisposalsTest()
                 counter.Add(1);
                 Assert.Equal(1, count);
 
-                histogram.Record(1);
+                upDownCounter.Add(-1);
                 Assert.Equal(2, count);
 
+                histogram.Record(1);
+                Assert.Equal(3, count);
+
                 listener.RecordObservableInstruments();
-                Assert.Equal(4, count);
+                Assert.Equal(6, count);
 
                 meter1.Dispose();
                 counter.Add(1);
-                Assert.Equal(4, count);
+                Assert.Equal(6, count);
 
                 meter2.Dispose();
                 histogram.Record(1);
-                Assert.Equal(4, count);
+                Assert.Equal(6, count);
 
-                listener.RecordObservableInstruments();
+                meter5.Dispose();
+                upDownCounter.Add(-10);
                 Assert.Equal(6, count);
 
+                listener.RecordObservableInstruments();
+                Assert.Equal(9, count);
+
                 meter3.Dispose();
                 listener.RecordObservableInstruments();
-                Assert.Equal(7, count);
+                Assert.Equal(11, count);
 
                 meter4.Dispose();
                 listener.RecordObservableInstruments();
-                Assert.Equal(7, count);
+                Assert.Equal(12, count);
+
+                meter6.Dispose();
+                listener.RecordObservableInstruments();
+                Assert.Equal(12, count);
 
             }).Dispose();
         }
@@ -589,9 +807,11 @@ public void ListenerDisposalsTest()
                 Meter meter = new Meter("ListenerDisposalsTest");
 
                 Counter<int> counter = meter.CreateCounter<int>("Counter");
+                UpDownCounter<short> upDownCounter = meter.CreateUpDownCounter<short>("upDownCounter");
                 Histogram<double> histogram = meter.CreateHistogram<double>("Histogram");
                 ObservableCounter<long> observableCounter = meter.CreateObservableCounter<long>("ObservableCounter", () => new Measurement<long>(10, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
                 ObservableGauge<decimal> observableGauge = meter.CreateObservableGauge<decimal>("ObservableGauge", () => new Measurement<decimal>(5.7m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
+                ObservableUpDownCounter<float> observableUpDownCounter = meter.CreateObservableUpDownCounter<float>("ObservableUpDownCounter", () => new Measurement<float>(-5.7f, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
 
                 int completedMeasurements = 0;
                 MeterListener listener = new MeterListener();
@@ -600,7 +820,9 @@ public void ListenerDisposalsTest()
 
                 int count = 0;
 
+                listener.SetMeasurementEventCallback<short>((inst, measurement, tags, state)   => count++);
                 listener.SetMeasurementEventCallback<int>((inst, measurement, tags, state)     => count++);
+                listener.SetMeasurementEventCallback<float>((inst, measurement, tags, state)   => count++);
                 listener.SetMeasurementEventCallback<double>((inst, measurement, tags, state)  => count++);
                 listener.SetMeasurementEventCallback<long>((inst, measurement, tags, state)    => count++);
                 listener.SetMeasurementEventCallback<decimal>((inst, measurement, tags, state) => count++);
@@ -612,23 +834,26 @@ public void ListenerDisposalsTest()
                 counter.Add(1);
                 Assert.Equal(1, count);
 
-                histogram.Record(1);
+                upDownCounter.Add(-1);
                 Assert.Equal(2, count);
 
+                histogram.Record(1);
+                Assert.Equal(3, count);
+
                 listener.RecordObservableInstruments();
-                Assert.Equal(4, count);
+                Assert.Equal(6, count);
 
                 listener.Dispose();
-                Assert.Equal(4, completedMeasurements);
+                Assert.Equal(6, completedMeasurements);
 
                 counter.Add(1);
-                Assert.Equal(4, count);
+                Assert.Equal(6, count);
 
                 histogram.Record(1);
-                Assert.Equal(4, count);
+                Assert.Equal(6, count);
 
                 listener.RecordObservableInstruments();
-                Assert.Equal(4, count);
+                Assert.Equal(6, count);
             }).Dispose();
         }
 
@@ -712,8 +937,10 @@ public void ParallelRunningTest()
                 Meter meter = new Meter("ParallelRunningTest");
 
                 Counter<int> counter = meter.CreateCounter<int>("Counter");
+                UpDownCounter<int> upDownCounter = meter.CreateUpDownCounter<int>("UpDownCounter");
                 Histogram<int> histogram = meter.CreateHistogram<int>("Histogram");
                 ObservableCounter<int> observableCounter = meter.CreateObservableCounter<int>("ObservableCounter", () => 1);
+                ObservableUpDownCounter<int> observableUpDownCounter = meter.CreateObservableUpDownCounter<int>("ObservableUpDownCounter", () => 1);
                 ObservableGauge<int> observableGauge = meter.CreateObservableGauge<int>("ObservableGauge", () => 1);
 
                 MeterListener listener = new MeterListener();
@@ -723,7 +950,7 @@ public void ParallelRunningTest()
                 listener.SetMeasurementEventCallback<int>((inst, measurement, tags, state) => Interlocked.Add(ref totalCount, measurement));
                 listener.Start();
 
-                Task[] taskList = new Task[6];
+                Task[] taskList = new Task[9];
 
                 int loopLength = 10_000;
 
@@ -733,10 +960,13 @@ public void ParallelRunningTest()
                 taskList[3] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { histogram.Record(1); } });
                 taskList[4] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { listener.RecordObservableInstruments(); } });
                 taskList[5] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { listener.RecordObservableInstruments(); } });
+                taskList[6] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { upDownCounter.Add(1); } });
+                taskList[7] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { upDownCounter.Add(1); } });
+                taskList[8] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { listener.RecordObservableInstruments(); } });
 
                 Task.WaitAll(taskList);
 
-                Assert.Equal(loopLength * 8, totalCount);
+                Assert.Equal(loopLength * 15, totalCount);
             }).Dispose();
         }
 
@@ -817,9 +1047,11 @@ public void TestRecordingMeasurementsWithTagList()
                 using (MeterListener listener = new MeterListener())
                 {
                     Counter<int> counter = meter.CreateCounter<int>("Counter");
+                    UpDownCounter<int> upDownCounter = meter.CreateUpDownCounter<int>("UpDownCounter");
                     Histogram<int> histogram = meter.CreateHistogram<int>("histogram");
 
                     listener.EnableMeasurementEvents(counter, counter);
+                    listener.EnableMeasurementEvents(upDownCounter, upDownCounter);
                     listener.EnableMeasurementEvents(histogram, histogram);
 
                     KeyValuePair<string, object?>[] expectedTags = null;
@@ -835,11 +1067,13 @@ public void TestRecordingMeasurementsWithTagList()
 
                     expectedTags = new KeyValuePair<string, object?>[0];
                     counter.Add(10, new TagList());
+                    upDownCounter.Add(-1, new TagList());
                     histogram.Record(10, new TagList());
 
                     // 1 Tags
                     expectedTags = new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key1", "Value1") };
                     counter.Add(10, new TagList() { expectedTags[0] });
+                    upDownCounter.Add(-2, new TagList() { expectedTags[0] });
                     histogram.Record(10, new TagList() { new KeyValuePair<string, object?>("Key1", "Value1") });
 
                     // 2 Tags
@@ -850,6 +1084,7 @@ public void TestRecordingMeasurementsWithTagList()
                     }.ToArray();
 
                     counter.Add(10, new TagList() { expectedTags[0], expectedTags[1] });
+                    upDownCounter.Add(-3, new TagList() { expectedTags[0], expectedTags[1] });
                     histogram.Record(10, new TagList() { expectedTags[0], expectedTags[1] });
 
                     // 8 Tags
@@ -866,6 +1101,7 @@ public void TestRecordingMeasurementsWithTagList()
                     }.ToArray();
 
                     counter.Add(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7] });
+                    upDownCounter.Add(-4, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7] });
                     histogram.Record(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7] });
 
                     // 13 Tags
@@ -888,6 +1124,8 @@ public void TestRecordingMeasurementsWithTagList()
 
                     counter.Add(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7],
                                                      expectedTags[8], expectedTags[9], expectedTags[10], expectedTags[11], expectedTags[12] });
+                    upDownCounter.Add(-5, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7],
+                                                     expectedTags[8], expectedTags[9], expectedTags[10], expectedTags[11], expectedTags[12] });
                     histogram.Record(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7],
                                                      expectedTags[8], expectedTags[9], expectedTags[10], expectedTags[11], expectedTags[12] });
                 }
@@ -913,6 +1151,24 @@ private void PublishCounterMeasurement<T>(Counter<T> counter, T value, KeyValueP
             }
         }
 
+        private void PublishUpDownCounterMeasurement<T>(UpDownCounter<T> counter, T value, KeyValuePair<string, object?>[] tags) where T : struct
+        {
+            switch (tags.Length)
+            {
+                case 0: counter.Add(value); break;
+                case 1: counter.Add(value, tags[0]); break;
+                case 2: counter.Add(value, tags[0], tags[1]); break;
+                case 3: counter.Add(value, tags[0], tags[1], tags[2]); break;
+                case 4: counter.Add(value, tags[0], tags[1], tags[2], tags[3]); break;
+                case 5: counter.Add(value, tags[0], tags[1], tags[2], tags[3], tags[4]); break;
+                case 6: counter.Add(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5]); break;
+                case 7: counter.Add(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5], tags[6]); break;
+                case 8: counter.Add(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5], tags[6], tags[7]); break;
+                case 9: counter.Add(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5], tags[6], tags[7], tags[8]); break;
+                default: counter.Add(value, tags); break;
+            }
+        }
+
         private void PublishHistogramMeasurement<T>(Histogram<T> histogram, T value, KeyValuePair<string, object?>[] tags) where T : struct
         {
             switch (tags.Length)
@@ -940,7 +1196,7 @@ private void ValidateInstrumentInfo(Instrument instrument, string name, string u
             Assert.Equal(isObservable, instrument.IsObservable);
         }
 
-        private void InstruementMeasurementAggregationValidation<T>(Instrument<T> instrument, Action<T, KeyValuePair<string, object?>[]> record) where T : struct
+        private void InstrumentMeasurementAggregationValidation<T>(Instrument<T> instrument, Action<T, KeyValuePair<string, object?>[]> record, bool allowNegative = false) where T : struct
         {
             using MeterListener listener = new MeterListener();
             listener.InstrumentPublished = (theInstrument, theListener) =>
@@ -968,17 +1224,28 @@ private void InstruementMeasurementAggregationValidation<T>(Instrument<T> instru
 
             listener.Start();
 
-            for (byte i = 0; i < 100; i++)
+            if (allowNegative && typeof(T) != typeof(Byte))
             {
-                expectedTags.Add(new KeyValuePair<string, object?>(i.ToString(), i.ToString()));
-                expectedValue = ConvertValue<T>(i);
-                record(expectedValue, expectedTags.ToArray());
+                for (short i = 0; i < 100; i++)
+                {
+                    expectedTags.Add(new KeyValuePair<string, object?>(i.ToString(), i.ToString()));
+                    expectedValue = ConvertValue<T>((short)(i % 2 == 0 ? 2 : -1));
+                    record(expectedValue, expectedTags.ToArray());
+                }
+            }
+            else
+            {
+                for (short i = 0; i < 100; i++)
+                {
+                    expectedTags.Add(new KeyValuePair<string, object?>(i.ToString(), i.ToString()));
+                    expectedValue = ConvertValue<T>(i);
+                    record(expectedValue, expectedTags.ToArray());
+                }
             }
-
             Assert.Equal(100, counter);
         }
 
-        private void ObservableInstruementMeasurementAggregationValidation<T>(ObservableInstrument<T> instrument, Measurement<T>[] expectedResult) where T : struct
+        private void ObservableInstrumentMeasurementAggregationValidation<T>(ObservableInstrument<T> instrument, Measurement<T>[] expectedResult) where T : struct
         {
             using MeterListener listener = new MeterListener();
             listener.InstrumentPublished = (theInstrument, theListener) =>
@@ -1121,10 +1388,10 @@ private void InstrumentPassingVariableTagsParametersTest<T>(Instrument<T> instru
             expectedValue = record(instrument, expectedValue, expectedTags);
         }
 
-        private T ConvertValue<T>(byte value) where T : struct
+        private T ConvertValue<T>(short value) where T : struct
         {
-            if (typeof(T) == typeof(byte))  { return (T)(object)value;}
-            if (typeof(T) == typeof(short)) { return (T)(object)Convert.ToInt16(value); }
+            if (typeof(T) == typeof(byte))  { return (T)(object)(byte)value; }
+            if (typeof(T) == typeof(short)) { return (T)(object)value; }
             if (typeof(T) == typeof(int)) { return (T)(object)Convert.ToInt32(value); }
             if (typeof(T) == typeof(long)) { return (T)(object)Convert.ToInt64(value); }
             if (typeof(T) == typeof(float)) { return (T)(object)Convert.ToSingle(value); }

From bc15ace8cef3bdd0b662bae64b2b43f5d8c2795d Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Thu, 27 Jan 2022 22:10:06 -0500
Subject: [PATCH 132/161] Change condition on RegexReductionTests to be
 explicit about trimming (#64411)

---
 .../Common/tests/TestUtilities/System/PlatformDetection.cs    | 1 +
 .../tests/RegexReductionTests.cs                              | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs b/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
index 857783a9e95c20..db1af4f4fba6d9 100644
--- a/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
+++ b/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs
@@ -182,6 +182,7 @@ public static bool IsMetadataTokenSupported
 
         // Changed to `true` when linking
         public static bool IsBuiltWithAggressiveTrimming => false;
+        public static bool IsNotBuiltWithAggressiveTrimming => !IsBuiltWithAggressiveTrimming;
 
         // Windows - Schannel supports alpn from win8.1/2012 R2 and higher.
         // Linux - OpenSsl supports alpn from openssl 1.0.2 and higher.
diff --git a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
index 02c6e3a8f24456..705eacb09f5fa7 100644
--- a/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
+++ b/src/libraries/System.Text.RegularExpressions/tests/RegexReductionTests.cs
@@ -7,7 +7,7 @@
 namespace System.Text.RegularExpressions.Tests
 {
     [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Many of these optimizations don't exist in .NET Framework.")]
-    [SkipOnPlatform(TestPlatforms.Browser, "Internal members accessed via reflection may have been trimmed away")]
+    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBuiltWithAggressiveTrimming))]
     public class RegexReductionTests
     {
         // These tests depend on using reflection to access internals of Regex in order to validate
@@ -26,7 +26,7 @@ public class RegexReductionTests
 
         static RegexReductionTests()
         {
-            if (PlatformDetection.IsNetFramework || PlatformDetection.IsBrowser)
+            if (PlatformDetection.IsNetFramework || PlatformDetection.IsBuiltWithAggressiveTrimming)
             {
                 // These members may not exist or may have been trimmed away, and the tests won't run.
                 return;

From 125ceba6102b8ae9adad96b95403e96fb25bdbcf Mon Sep 17 00:00:00 2001
From: Will Smith <lol.tihan@gmail.com>
Date: Thu, 27 Jan 2022 19:30:22 -0800
Subject: [PATCH 133/161] Removing `tiVerificationNeeded` in the JIT (#64356)

* Removing tiVerificationNeeded in the JIT

* Removed addVerifyFlag

* Fixing build

* format

* Format fixes
---
 src/coreclr/jit/compiler.cpp  |  13 +-
 src/coreclr/jit/compiler.h    |   7 -
 src/coreclr/jit/compiler.hpp  |  10 +-
 src/coreclr/jit/ee_il_dll.hpp |   8 -
 src/coreclr/jit/error.cpp     |   6 +-
 src/coreclr/jit/fgbasic.cpp   |   7 +-
 src/coreclr/jit/importer.cpp  | 981 ++--------------------------------
 src/coreclr/jit/lclvars.cpp   |  69 +--
 src/coreclr/jit/typeinfo.cpp  |  63 +--
 9 files changed, 55 insertions(+), 1109 deletions(-)

diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp
index f6299e5bf35619..cf87223f71760b 100644
--- a/src/coreclr/jit/compiler.cpp
+++ b/src/coreclr/jit/compiler.cpp
@@ -5625,11 +5625,8 @@ int Compiler::compCompile(CORINFO_MODULE_HANDLE classPtr,
 
     // Set this before the first 'BADCODE'
     // Skip verification where possible
-    //.tiVerificationNeeded = !compileFlags->IsSet(JitFlags::JIT_FLAG_SKIP_VERIFICATION);
     assert(compileFlags->IsSet(JitFlags::JIT_FLAG_SKIP_VERIFICATION));
 
-    assert(!compIsForInlining() || !tiVerificationNeeded); // Inlinees must have been verified.
-
     /* Setup an error trap */
 
     struct Param
@@ -6156,17 +6153,9 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr,
                 eeGetMethodFullName(info.compMethodHnd), dspPtr(impTokenLookupContextHandle)));
     }
 
-    if (tiVerificationNeeded)
-    {
-        JITLOG((LL_INFO10000, "tiVerificationNeeded initially set to true for %s\n", info.compFullName));
-    }
 #endif // DEBUG
 
-    /* Since tiVerificationNeeded can be turned off in the middle of
-       compiling a method, and it might have caused blocks to be queued up
-       for reimporting, impCanReimport can be used to check for reimporting. */
-
-    impCanReimport = (tiVerificationNeeded || compStressCompile(STRESS_CHK_REIMPORT, 15));
+    impCanReimport = compStressCompile(STRESS_CHK_REIMPORT, 15);
 
     /* Initialize set a bunch of global values */
 
diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
index ba19b8445afbff..3f423e8e38f1f6 100644
--- a/src/coreclr/jit/compiler.h
+++ b/src/coreclr/jit/compiler.h
@@ -8084,7 +8084,6 @@ class Compiler
                        CORINFO_RESOLVED_TOKEN* pConstrainedToken,
                        CORINFO_CALLINFO_FLAGS  flags,
                        CORINFO_CALL_INFO*      pResult);
-    inline CORINFO_CALLINFO_FLAGS addVerifyFlag(CORINFO_CALLINFO_FLAGS flags);
 
     void eeGetFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
                         CORINFO_ACCESS_FLAGS    flags,
@@ -10715,12 +10714,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     */
 
 public:
-    // Set to true if verification cannot be skipped for this method
-    // CoreCLR does not ever run IL verification. Compile out the verifier from the JIT by making this a constant.
-    // TODO: Delete the verifier from the JIT? (https://github.com/dotnet/runtime/issues/32648)
-    // bool tiVerificationNeeded;
-    static const bool tiVerificationNeeded = false;
-
     // Returns true if child is equal to or a subtype of parent for merge purposes
     // This support is necessary to suport attributes that are not described in
     // for example, signatures. For example, the permanent home byref (byref that
diff --git a/src/coreclr/jit/compiler.hpp b/src/coreclr/jit/compiler.hpp
index 464cafeb72750e..fa6863bef0d2d8 100644
--- a/src/coreclr/jit/compiler.hpp
+++ b/src/coreclr/jit/compiler.hpp
@@ -2355,29 +2355,29 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 
 inline unsigned Compiler::compMapILargNum(unsigned ILargNum)
 {
-    assert(ILargNum < info.compILargsCount || tiVerificationNeeded);
+    assert(ILargNum < info.compILargsCount);
 
     // Note that this works because if compRetBuffArg/compTypeCtxtArg/lvVarargsHandleArg are not present
     // they will be BAD_VAR_NUM (MAX_UINT), which is larger than any variable number.
     if (ILargNum >= info.compRetBuffArg)
     {
         ILargNum++;
-        assert(ILargNum < info.compLocalsCount || tiVerificationNeeded); // compLocals count already adjusted.
+        assert(ILargNum < info.compLocalsCount); // compLocals count already adjusted.
     }
 
     if (ILargNum >= (unsigned)info.compTypeCtxtArg)
     {
         ILargNum++;
-        assert(ILargNum < info.compLocalsCount || tiVerificationNeeded); // compLocals count already adjusted.
+        assert(ILargNum < info.compLocalsCount); // compLocals count already adjusted.
     }
 
     if (ILargNum >= (unsigned)lvaVarargsHandleArg)
     {
         ILargNum++;
-        assert(ILargNum < info.compLocalsCount || tiVerificationNeeded); // compLocals count already adjusted.
+        assert(ILargNum < info.compLocalsCount); // compLocals count already adjusted.
     }
 
-    assert(ILargNum < info.compArgsCount || tiVerificationNeeded);
+    assert(ILargNum < info.compArgsCount);
     return (ILargNum);
 }
 
diff --git a/src/coreclr/jit/ee_il_dll.hpp b/src/coreclr/jit/ee_il_dll.hpp
index 33d5fab12ac5bf..337ca8f1479775 100644
--- a/src/coreclr/jit/ee_il_dll.hpp
+++ b/src/coreclr/jit/ee_il_dll.hpp
@@ -294,11 +294,3 @@ inline CORINFO_CALLINFO_FLAGS combine(CORINFO_CALLINFO_FLAGS flag1, CORINFO_CALL
 {
     return (CORINFO_CALLINFO_FLAGS)(flag1 | flag2);
 }
-inline CORINFO_CALLINFO_FLAGS Compiler::addVerifyFlag(CORINFO_CALLINFO_FLAGS flags)
-{
-    if (tiVerificationNeeded)
-    {
-        flags = combine(flags, CORINFO_CALLINFO_VERIFICATION);
-    }
-    return flags;
-}
diff --git a/src/coreclr/jit/error.cpp b/src/coreclr/jit/error.cpp
index 1845af97b5731f..dfb5a859b43008 100644
--- a/src/coreclr/jit/error.cpp
+++ b/src/coreclr/jit/error.cpp
@@ -258,11 +258,7 @@ void debugError(const char* msg, const char* file, unsigned line)
     // If ComPlus_JitRequired is 0 or is not set, we will not assert.
     if (JitConfig.JitRequired() == 1 || getBreakOnBadCode())
     {
-        // Don't assert if verification is done.
-        if (!env->compiler->tiVerificationNeeded || getBreakOnBadCode())
-        {
-            assertAbort(msg, file, line);
-        }
+        assertAbort(msg, file, line);
     }
 
     BreakIfDebuggerPresent();
diff --git a/src/coreclr/jit/fgbasic.cpp b/src/coreclr/jit/fgbasic.cpp
index 6725fc1f2bfe9c..7f8bd7b01c6d03 100644
--- a/src/coreclr/jit/fgbasic.cpp
+++ b/src/coreclr/jit/fgbasic.cpp
@@ -2229,7 +2229,7 @@ void Compiler::fgAdjustForAddressExposedOrWrittenThis()
     LclVarDsc* thisVarDsc = lvaGetDesc(info.compThisArg);
 
     // Optionally enable adjustment during stress.
-    if (!tiVerificationNeeded && compStressCompile(STRESS_GENERIC_VARN, 15))
+    if (compStressCompile(STRESS_GENERIC_VARN, 15))
     {
         thisVarDsc->lvHasILStoreOp = true;
     }
@@ -3516,9 +3516,6 @@ void Compiler::fgFindBasicBlocks()
 
 #endif // !FEATURE_EH_FUNCLETS
 
-#ifndef DEBUG
-    if (tiVerificationNeeded)
-#endif
     {
         // always run these checks for a debug build
         verCheckNestingLevel(initRoot);
@@ -3527,7 +3524,7 @@ void Compiler::fgFindBasicBlocks()
 #ifndef DEBUG
     // fgNormalizeEH assumes that this test has been passed.  And Ssa assumes that fgNormalizeEHTable
     // has been run.  So do this unless we're in minOpts mode (and always in debug).
-    if (tiVerificationNeeded || !opts.MinOpts())
+    if (!opts.MinOpts())
 #endif
     {
         fgCheckBasicBlockControlFlow();
diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp
index ca697139a8904c..b9cc2ff883d64a 100644
--- a/src/coreclr/jit/importer.cpp
+++ b/src/coreclr/jit/importer.cpp
@@ -91,42 +91,6 @@ void Compiler::impPushOnStack(GenTree* tree, typeInfo ti)
         CORINFO_CLASS_HANDLE clsHnd = ti.GetClassHandle();
         assert(clsHnd != NO_CLASS_HANDLE);
     }
-
-    if (tiVerificationNeeded && !ti.IsDead())
-    {
-        assert(typeInfo::AreEquivalent(NormaliseForStack(ti), ti)); // types are normalized
-
-        // The ti type is consistent with the tree type.
-        //
-
-        // On 64-bit systems, nodes whose "proper" type is "native int" get labeled TYP_LONG.
-        // In the verification type system, we always transform "native int" to "TI_INT".
-        // Ideally, we would keep track of which nodes labeled "TYP_LONG" are really "native int", but
-        // attempts to do that have proved too difficult.  Instead, we'll assume that in checks like this,
-        // when there's a mismatch, it's because of this reason -- the typeInfo::AreEquivalentModuloNativeInt
-        // method used in the last disjunct allows exactly this mismatch.
-        assert(ti.IsDead() || (ti.IsByRef() && ((tree->TypeGet() == TYP_I_IMPL) || (tree->TypeGet() == TYP_BYREF))) ||
-               (ti.IsUnboxedGenericTypeVar() && tree->TypeGet() == TYP_REF) ||
-               (ti.IsObjRef() && tree->TypeGet() == TYP_REF) || (ti.IsMethod() && tree->TypeGet() == TYP_I_IMPL) ||
-               (ti.IsType(TI_STRUCT) && tree->TypeGet() != TYP_REF) ||
-               typeInfo::AreEquivalentModuloNativeInt(NormaliseForStack(ti),
-                                                      NormaliseForStack(typeInfo(tree->TypeGet()))));
-
-        // If it is a struct type, make certain we normalized the primitive types
-        assert(!ti.IsType(TI_STRUCT) ||
-               info.compCompHnd->getTypeForPrimitiveValueClass(ti.GetClassHandle()) == CORINFO_TYPE_UNDEF);
-    }
-
-#if VERBOSE_VERIFY
-    if (VERBOSE && tiVerificationNeeded)
-    {
-        printf("\n");
-        printf(TI_DUMP_PADDING);
-        printf("About to push to stack: ");
-        ti.Dump();
-    }
-#endif // VERBOSE_VERIFY
-
 #endif // DEBUG
 
     verCurrentState.esStack[verCurrentState.esStackDepth].seTypeInfo = ti;
@@ -257,14 +221,7 @@ void Compiler::impResolveToken(const BYTE* addr, CORINFO_RESOLVED_TOKEN* pResolv
     pResolvedToken->token        = getU4LittleEndian(addr);
     pResolvedToken->tokenType    = kind;
 
-    if (!tiVerificationNeeded)
-    {
-        info.compCompHnd->resolveToken(pResolvedToken);
-    }
-    else
-    {
-        Verify(eeTryResolveToken(pResolvedToken), "Token resolution failed");
-    }
+    info.compCompHnd->resolveToken(pResolvedToken);
 }
 
 /*****************************************************************************
@@ -279,19 +236,6 @@ StackEntry Compiler::impPopStack()
         BADCODE("stack underflow");
     }
 
-#ifdef DEBUG
-#if VERBOSE_VERIFY
-    if (VERBOSE && tiVerificationNeeded)
-    {
-        JITDUMP("\n");
-        printf(TI_DUMP_PADDING);
-        printf("About to pop from the stack: ");
-        const typeInfo& ti = verCurrentState.esStack[verCurrentState.esStackDepth - 1].seTypeInfo;
-        ti.Dump();
-    }
-#endif // VERBOSE_VERIFY
-#endif // DEBUG
-
     return verCurrentState.esStack[--verCurrentState.esStackDepth];
 }
 
@@ -824,7 +768,7 @@ void Compiler::impAssignTempGen(unsigned             tmpNum,
         // so at least ignore it in the case when verification is turned on
         // since any block that tries to use the temp would have failed verification.
         var_types varType = lvaTable[tmpNum].lvType;
-        assert(tiVerificationNeeded || varType == TYP_UNDEF || varTypeIsStruct(varType));
+        assert(varType == TYP_UNDEF || varTypeIsStruct(varType));
         lvaSetStruct(tmpNum, structType, false);
 
         varType = lvaTable[tmpNum].lvType;
@@ -2487,21 +2431,9 @@ bool Compiler::impSpillStackEntry(unsigned level,
 
     /* Allocate a temp if we haven't been asked to use a particular one */
 
-    if (tiVerificationNeeded)
-    {
-        // Ignore bad temp requests (they will happen with bad code and will be
-        // catched when importing the destblock)
-        if (tnum != BAD_VAR_NUM && tnum >= lvaCount)
-        {
-            return false;
-        }
-    }
-    else
+    if (tnum != BAD_VAR_NUM && (tnum >= lvaCount))
     {
-        if (tnum != BAD_VAR_NUM && (tnum >= lvaCount))
-        {
-            return false;
-        }
+        return false;
     }
 
     bool isNewTemp = false;
@@ -2511,27 +2443,6 @@ bool Compiler::impSpillStackEntry(unsigned level,
         tnum      = lvaGrabTemp(true DEBUGARG(reason));
         isNewTemp = true;
     }
-    else if (tiVerificationNeeded && lvaTable[tnum].TypeGet() != TYP_UNDEF)
-    {
-        // if verification is needed and tnum's type is incompatible with
-        // type on that stack, we grab a new temp. This is safe since
-        // we will throw a verification exception in the dest block.
-
-        var_types valTyp = tree->TypeGet();
-        var_types dstTyp = lvaTable[tnum].TypeGet();
-
-        // if the two types are different, we return. This will only happen with bad code and will
-        // be catched when importing the destblock. We still allow int/byrefs and float/double differences.
-        if ((genActualType(valTyp) != genActualType(dstTyp)) &&
-            !(
-#ifndef TARGET_64BIT
-                (valTyp == TYP_I_IMPL && dstTyp == TYP_BYREF) || (valTyp == TYP_BYREF && dstTyp == TYP_I_IMPL) ||
-#endif // !TARGET_64BIT
-                (varTypeIsFloating(dstTyp) && varTypeIsFloating(valTyp))))
-        {
-            return false;
-        }
-    }
 
     /* Assign the spilled entry to the temp */
     impAssignTempGen(tnum, tree, verCurrentState.esStack[level].seTypeInfo.GetClassHandle(), level);
@@ -6358,8 +6269,8 @@ void Compiler::verVerifyCall(OPCODE                  opcode,
                 info.compCompHnd->resolveToken(&delegateResolvedToken);
 
                 CORINFO_CALL_INFO delegateCallInfo;
-                eeGetCallInfo(&delegateResolvedToken, nullptr /* constraint typeRef */,
-                              addVerifyFlag(CORINFO_CALLINFO_SECURITYCHECKS), &delegateCallInfo);
+                eeGetCallInfo(&delegateResolvedToken, nullptr /* constraint typeRef */, CORINFO_CALLINFO_SECURITYCHECKS,
+                              &delegateCallInfo);
 
                 bool isOpenDelegate = false;
                 VerifyOrReturn(info.compCompHnd->isCompatibleDelegate(objTypeHandle, delegateResolvedToken.hClass,
@@ -9615,9 +9526,6 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
             {
                 if (newobjThis->gtOper == GT_COMMA)
                 {
-                    // In coreclr the callout can be inserted even if verification is disabled
-                    // so we cannot rely on tiVerificationNeeded alone
-
                     // We must have inserted the callout. Get the real newobj.
                     newobjThis = newobjThis->AsOp()->gtOp2;
                 }
@@ -9926,14 +9834,6 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
             eeGetCallSiteSig(pResolvedToken->token, pResolvedToken->tokenScope, pResolvedToken->tokenContext, sig);
         }
 
-        // Find the return type used for verification by interpreting the method signature.
-        // NB: we are clobbering the already established sig.
-        if (tiVerificationNeeded)
-        {
-            // Actually, we never get the sig for the original method.
-            sig = &(callInfo->verSig);
-        }
-
         typeInfo tiRetVal = verMakeTypeInfo(sig->retType, sig->retTypeClass);
         tiRetVal.NormaliseForStack();
 
@@ -9944,17 +9844,6 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
             tiRetVal.SetIsReadonlyByRef();
         }
 
-        if (tiVerificationNeeded)
-        {
-            // We assume all calls return permanent home byrefs. If they
-            // didn't they wouldn't be verifiable. This is also covering
-            // the Address() helper for multidimensional arrays.
-            if (tiRetVal.IsByRef())
-            {
-                tiRetVal.SetIsPermanentHomeByRef();
-            }
-        }
-
         if (call->IsCall())
         {
             // Sometimes "call" is not a GT_CALL (if we imported an intrinsic that didn't turn into a call)
@@ -11794,13 +11683,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
     CORINFO_HELPER_DESC          calloutHelper;
     const BYTE*                  lastLoadToken = nullptr;
 
-    // reject cyclic constraints
-    if (tiVerificationNeeded)
-    {
-        Verify(!info.hasCircularClassConstraints, "Method parent has circular class type parameter constraints.");
-        Verify(!info.hasCircularMethodConstraints, "Method has circular method type parameter constraints.");
-    }
-
     /* Get the tree list started */
 
     impBeginTreeList();
@@ -12346,11 +12228,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 val = getU4LittleEndian(codeAddr);
                 JITDUMP(" %08X", val);
-                if (tiVerificationNeeded)
-                {
-                    Verify(info.compCompHnd->isValidStringRef(info.compScopeHnd, val), "bad string");
-                    tiRetVal = typeInfo(TI_REF, impGetStringClass());
-                }
                 impPushOnStack(gtNewSconNode(val, info.compScopeHnd), tiRetVal);
 
                 break;
@@ -12406,11 +12283,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
             STARG:
                 JITDUMP(" %u", lclNum);
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(lclNum < info.compILargsCount, "bad arg num");
-                }
-
                 if (compIsForInlining())
                 {
                     op1 = impInlineFetchArg(lclNum, impInlineInfo->inlArgInfo, impInlineInfo->lclVarInfo);
@@ -12431,18 +12303,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 // We should have seen this arg write in the prescan
                 assert(lvaTable[lclNum].lvHasILStoreOp);
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo& tiLclVar = lvaTable[lclNum].lvVerTypeInfo;
-                    Verify(tiCompatibleWith(impStackTop().seTypeInfo, NormaliseForStack(tiLclVar), true),
-                           "type mismatch");
-
-                    if (verTrackObjCtorInitState && (verCurrentState.thisInitialized != TIS_Init))
-                    {
-                        Verify(!tiLclVar.IsThisPtr(), "storing to uninit this ptr");
-                    }
-                }
-
                 goto VAR_ST;
 
             case CEE_STLOC:
@@ -12466,14 +12326,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 assert(lclNum >= 0 && lclNum < 4);
 
             LOC_ST:
-                if (tiVerificationNeeded)
-                {
-                    Verify(lclNum < info.compMethodInfo->locals.numArgs, "bad local num");
-                    Verify(tiCompatibleWith(impStackTop().seTypeInfo,
-                                            NormaliseForStack(lvaTable[lclNum + numArgs].lvVerTypeInfo), true),
-                           "type mismatch");
-                }
-
                 if (compIsForInlining())
                 {
                     lclTyp = impInlineInfo->lclVarInfo[lclNum + impInlineInfo->argCnt].lclTypeInfo;
@@ -12491,7 +12343,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 if (lclNum >= info.compLocalsCount && lclNum != lvaArg0Var)
                 {
-                    assert(!tiVerificationNeeded); // We should have thrown the VerificationException before.
                     BADCODE("Bad IL");
                 }
 
@@ -12533,7 +12384,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 // Downcast the TYP_I_IMPL into a 32-bit Int for x86 JIT compatiblity
                 if (varTypeIsI(op1->TypeGet()) && (genActualType(lclTyp) == TYP_INT))
                 {
-                    assert(!tiVerificationNeeded); // We should have thrown the VerificationException before.
                     op1 = gtNewCastNode(TYP_INT, op1, false, TYP_INT);
                 }
 #endif // TARGET_64BIT
@@ -12647,11 +12497,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 lclNum = getU1LittleEndian(codeAddr);
             LDLOCA:
                 JITDUMP(" %u", lclNum);
-                if (tiVerificationNeeded)
-                {
-                    Verify(lclNum < info.compMethodInfo->locals.numArgs, "bad local num");
-                    Verify(info.compInitMem, "initLocals not set");
-                }
 
                 if (compIsForInlining())
                 {
@@ -12728,23 +12573,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 assert((op1->gtFlags & GTF_GLOB_REF) == 0);
 
                 tiRetVal = lvaTable[lclNum].lvVerTypeInfo;
-                if (tiVerificationNeeded)
-                {
-                    // Don't allow taking address of uninit this ptr.
-                    if (verTrackObjCtorInitState && (verCurrentState.thisInitialized != TIS_Init))
-                    {
-                        Verify(!tiRetVal.IsThisPtr(), "address of uninit this ptr");
-                    }
-
-                    if (!tiRetVal.IsByRef())
-                    {
-                        tiRetVal.MakeByRef();
-                    }
-                    else
-                    {
-                        Verify(false, "byref to byref");
-                    }
-                }
 
                 impPushOnStack(op1, tiRetVal);
                 break;
@@ -12756,10 +12584,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     BADCODE("arglist in non-vararg method");
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    tiRetVal = typeInfo(TI_STRUCT, impGetRuntimeArgumentHandle());
-                }
                 assertImp((info.compMethodInfo->args.callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_VARARG);
 
                 /* The ARGLIST cookie is a hidden 'last' parameter, we have already
@@ -12811,11 +12635,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     BADCODE("endfilter outside filter");
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(impStackTop().seTypeInfo.IsType(TI_INT), "bad endfilt arg");
-                }
-
                 op1 = impPopStack().val;
                 assertImp(op1->gtType == TYP_INT);
                 if (!bbInFilterILRange(block))
@@ -12854,11 +12673,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 assert(!compIsForInlining());
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(false, "Invalid opcode: CEE_JMP");
-                }
-
                 if ((info.compFlags & CORINFO_FLG_SYNCH) || block->hasTryIndex() || block->hasHndIndex())
                 {
                     /* CEE_JMP does not make sense in some "protected" regions. */
@@ -12915,30 +12729,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 ldelemClsHnd = resolvedToken.hClass;
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiArray = impStackTop(1).seTypeInfo;
-                    typeInfo tiIndex = impStackTop().seTypeInfo;
-
-                    // As per ECMA 'index' specified can be either int32 or native int.
-                    Verify(tiIndex.IsIntOrNativeIntType(), "bad index");
-
-                    typeInfo arrayElemType = verMakeTypeInfo(ldelemClsHnd);
-                    Verify(tiArray.IsNullObjRef() ||
-                               typeInfo::AreEquivalent(verGetArrayElemType(tiArray), arrayElemType),
-                           "bad array");
-
-                    tiRetVal = arrayElemType;
-                    tiRetVal.MakeByRef();
-                    if (prefixFlags & PREFIX_READONLY)
-                    {
-                        tiRetVal.SetIsReadonlyByRef();
-                    }
-
-                    // an array interior pointer is always in the heap
-                    tiRetVal.SetIsPermanentHomeByRef();
-                }
-
                 // If it's a value class array we just do a simple address-of
                 if (eeIsValueClass(ldelemClsHnd))
                 {
@@ -12989,20 +12779,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 ldelemClsHnd = resolvedToken.hClass;
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiArray = impStackTop(1).seTypeInfo;
-                    typeInfo tiIndex = impStackTop().seTypeInfo;
-
-                    // As per ECMA 'index' specified can be either int32 or native int.
-                    Verify(tiIndex.IsIntOrNativeIntType(), "bad index");
-                    tiRetVal = verMakeTypeInfo(ldelemClsHnd);
-
-                    Verify(tiArray.IsNullObjRef() || tiCompatibleWith(verGetArrayElemType(tiArray), tiRetVal, false),
-                           "type of array incompatible with type operand");
-                    tiRetVal.NormaliseForStack();
-                }
-
                 // If it's a reference type or generic variable type
                 // then just generate code as though it's a ldelem.ref instruction
                 if (!eeIsValueClass(ldelemClsHnd))
@@ -13058,47 +12834,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 goto ARR_LD;
 
             ARR_LD:
-
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiArray = impStackTop(1).seTypeInfo;
-                    typeInfo tiIndex = impStackTop().seTypeInfo;
-
-                    // As per ECMA 'index' specified can be either int32 or native int.
-                    Verify(tiIndex.IsIntOrNativeIntType(), "bad index");
-                    if (tiArray.IsNullObjRef())
-                    {
-                        if (lclTyp == TYP_REF)
-                        { // we will say a deref of a null array yields a null ref
-                            tiRetVal = typeInfo(TI_NULL);
-                        }
-                        else
-                        {
-                            tiRetVal = typeInfo(lclTyp);
-                        }
-                    }
-                    else
-                    {
-                        tiRetVal             = verGetArrayElemType(tiArray);
-                        typeInfo arrayElemTi = typeInfo(lclTyp);
-#ifdef TARGET_64BIT
-                        if (opcode == CEE_LDELEM_I)
-                        {
-                            arrayElemTi = typeInfo::nativeInt();
-                        }
-
-                        if (lclTyp != TYP_REF && lclTyp != TYP_STRUCT)
-                        {
-                            Verify(typeInfo::AreEquivalent(tiRetVal, arrayElemTi), "bad array");
-                        }
-                        else
-#endif // TARGET_64BIT
-                        {
-                            Verify(tiRetVal.IsType(arrayElemTi.GetType()), "bad array");
-                        }
-                    }
-                    tiRetVal.NormaliseForStack();
-                }
             ARR_LD_POST_VERIFY:
 
                 /* Pull the index value and array address */
@@ -13193,22 +12928,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 stelemClsHnd = resolvedToken.hClass;
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiArray = impStackTop(2).seTypeInfo;
-                    typeInfo tiIndex = impStackTop(1).seTypeInfo;
-                    typeInfo tiValue = impStackTop().seTypeInfo;
-
-                    // As per ECMA 'index' specified can be either int32 or native int.
-                    Verify(tiIndex.IsIntOrNativeIntType(), "bad index");
-                    typeInfo arrayElem = verMakeTypeInfo(stelemClsHnd);
-
-                    Verify(tiArray.IsNullObjRef() || tiCompatibleWith(arrayElem, verGetArrayElemType(tiArray), false),
-                           "type operand incompatible with array element type");
-                    arrayElem.NormaliseForStack();
-                    Verify(tiCompatibleWith(tiValue, arrayElem, true), "value incompatible with type operand");
-                }
-
                 // If it's a reference type just behave as though it's a stelem.ref instruction
                 if (!eeIsValueClass(stelemClsHnd))
                 {
@@ -13223,21 +12942,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 }
 
             case CEE_STELEM_REF:
-
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiArray = impStackTop(2).seTypeInfo;
-                    typeInfo tiIndex = impStackTop(1).seTypeInfo;
-                    typeInfo tiValue = impStackTop().seTypeInfo;
-
-                    // As per ECMA 'index' specified can be either int32 or native int.
-                    Verify(tiIndex.IsIntOrNativeIntType(), "bad index");
-                    Verify(tiValue.IsObjRef(), "bad value");
-
-                    // we only check that it is an object referece, The helper does additional checks
-                    Verify(tiArray.IsNullObjRef() || verGetArrayElemType(tiArray).IsType(TI_REF), "bad array");
-                }
-
             STELEM_REF_POST_VERIFY:
 
                 if (opts.OptimizationEnabled())
@@ -13280,29 +12984,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 goto ARR_ST;
 
             ARR_ST:
-
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiArray = impStackTop(2).seTypeInfo;
-                    typeInfo tiIndex = impStackTop(1).seTypeInfo;
-                    typeInfo tiValue = impStackTop().seTypeInfo;
-
-                    // As per ECMA 'index' specified can be either int32 or native int.
-                    Verify(tiIndex.IsIntOrNativeIntType(), "bad index");
-                    typeInfo arrayElem = typeInfo(lclTyp);
-#ifdef TARGET_64BIT
-                    if (opcode == CEE_STELEM_I)
-                    {
-                        arrayElem = typeInfo::nativeInt();
-                    }
-#endif // TARGET_64BIT
-                    Verify(tiArray.IsNullObjRef() || typeInfo::AreEquivalent(verGetArrayElemType(tiArray), arrayElem),
-                           "bad array");
-
-                    Verify(tiCompatibleWith(NormaliseForStack(tiValue), arrayElem.NormaliseForStack(), true),
-                           "bad value");
-                }
-
             ARR_ST_POST_VERIFY:
                 /* The strict order of evaluation is LHS-operands, RHS-operands,
                    range-check, and then assignment. However, codegen currently
@@ -13469,33 +13150,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 /* Pull two values and push back the result */
 
-                if (tiVerificationNeeded)
-                {
-                    const typeInfo& tiOp1 = impStackTop(1).seTypeInfo;
-                    const typeInfo& tiOp2 = impStackTop().seTypeInfo;
-
-                    Verify(tiCompatibleWith(tiOp1, tiOp2, true), "different arg type");
-                    if (oper == GT_ADD || oper == GT_DIV || oper == GT_SUB || oper == GT_MUL || oper == GT_MOD)
-                    {
-                        Verify(tiOp1.IsNumberType(), "not number");
-                    }
-                    else
-                    {
-                        Verify(tiOp1.IsIntegerType(), "not integer");
-                    }
-
-                    Verify(!ovfl || tiOp1.IsIntegerType(), "not integer");
-
-                    tiRetVal = tiOp1;
-
-#ifdef TARGET_64BIT
-                    if (tiOp2.IsNativeIntType())
-                    {
-                        tiRetVal = tiOp2;
-                    }
-#endif // TARGET_64BIT
-                }
-
                 op2 = impPopStack().val;
                 op1 = impPopStack().val;
 
@@ -13600,13 +13254,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 goto CEE_SH_OP2;
 
             CEE_SH_OP2:
-                if (tiVerificationNeeded)
-                {
-                    const typeInfo& tiVal   = impStackTop(1).seTypeInfo;
-                    const typeInfo& tiShift = impStackTop(0).seTypeInfo;
-                    Verify(tiVal.IsIntegerType() && tiShift.IsType(TI_INT), "Bad shift args");
-                    tiRetVal = tiVal;
-                }
                 op2 = impPopStack().val;
                 op1 = impPopStack().val; // operand to be shifted
                 impBashVarAddrsToI(op1, op2);
@@ -13618,12 +13265,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 break;
 
             case CEE_NOT:
-                if (tiVerificationNeeded)
-                {
-                    tiRetVal = impStackTop().seTypeInfo;
-                    Verify(tiRetVal.IsIntegerType(), "bad int value");
-                }
-
                 op1 = impPopStack().val;
                 impBashVarAddrsToI(op1, nullptr);
                 type = genActualType(op1->TypeGet());
@@ -13631,11 +13272,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 break;
 
             case CEE_CKFINITE:
-                if (tiVerificationNeeded)
-                {
-                    tiRetVal = impStackTop().seTypeInfo;
-                    Verify(tiRetVal.IsType(TI_DOUBLE), "bad R value");
-                }
                 op1  = impPopStack().val;
                 type = op1->TypeGet();
                 op1  = gtNewOperNode(GT_CKFINITE, type, op1);
@@ -13692,12 +13328,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
             case CEE_BRFALSE_S:
 
                 /* Pop the comparand (now there's a neat term) from the stack */
-                if (tiVerificationNeeded)
-                {
-                    typeInfo& tiVal = impStackTop().seTypeInfo;
-                    Verify(tiVal.IsObjRef() || tiVal.IsByRef() || tiVal.IsIntegerType() || tiVal.IsMethod(),
-                           "bad value");
-                }
 
                 op1  = impPopStack().val;
                 type = op1->TypeGet();
@@ -13820,12 +13450,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 goto CMP_2_OPs;
 
             CMP_2_OPs:
-                if (tiVerificationNeeded)
-                {
-                    verVerifyCond(impStackTop(1).seTypeInfo, impStackTop().seTypeInfo, opcode);
-                    tiRetVal = typeInfo(TI_INT);
-                }
-
                 op2 = impPopStack().val;
                 op1 = impPopStack().val;
 
@@ -13928,12 +13552,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 unordered = false;
                 goto CMP_2_OPs_AND_BR_ALL;
             CMP_2_OPs_AND_BR_ALL:
-
-                if (tiVerificationNeeded)
-                {
-                    verVerifyCond(impStackTop(1).seTypeInfo, impStackTop().seTypeInfo, opcode);
-                }
-
                 /* Pull two values */
                 op2 = impPopStack().val;
                 op1 = impPopStack().val;
@@ -14021,10 +13639,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 goto COND_JUMP;
 
             case CEE_SWITCH:
-                if (tiVerificationNeeded)
-                {
-                    Verify(impStackTop().seTypeInfo.IsType(TI_INT), "Bad switch val");
-                }
                 /* Pop the switch value off the stack */
                 op1 = impPopStack().val;
                 assertImp(genActualTypeIsIntOrI(op1->TypeGet()));
@@ -14175,40 +13789,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 goto _CONV;
 
             _CONV:
-                // just check that we have a number on the stack
-                if (tiVerificationNeeded)
-                {
-                    const typeInfo& tiVal = impStackTop().seTypeInfo;
-                    Verify(tiVal.IsNumberType(), "bad arg");
-
-#ifdef TARGET_64BIT
-                    bool isNative = false;
-
-                    switch (opcode)
-                    {
-                        case CEE_CONV_OVF_I:
-                        case CEE_CONV_OVF_I_UN:
-                        case CEE_CONV_I:
-                        case CEE_CONV_OVF_U:
-                        case CEE_CONV_OVF_U_UN:
-                        case CEE_CONV_U:
-                            isNative = true;
-                            break;
-                        default:
-                            // leave 'isNative' = false;
-                            break;
-                    }
-                    if (isNative)
-                    {
-                        tiRetVal = typeInfo::nativeInt();
-                    }
-                    else
-#endif // TARGET_64BIT
-                    {
-                        tiRetVal = typeInfo(lclTyp).NormaliseForStack();
-                    }
-                }
-
                 // only converts from FLOAT or DOUBLE to an integer type
                 // and converts from  ULONG (or LONG on ARM) to DOUBLE are morphed to calls
 
@@ -14324,12 +13904,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 break;
 
             case CEE_NEG:
-                if (tiVerificationNeeded)
-                {
-                    tiRetVal = impStackTop().seTypeInfo;
-                    Verify(tiRetVal.IsNumberType(), "Bad arg");
-                }
-
                 op1 = impPopStack().val;
                 impBashVarAddrsToI(op1, nullptr);
                 impPushOnStack(gtNewOperNode(GT_NEG, genActualType(op1->gtType), op1), tiRetVal);
@@ -14418,13 +13992,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
             case CEE_DUP:
             {
-                if (tiVerificationNeeded)
-                {
-                    // Dup could start the beginning of delegate creation sequence, remember that
-                    delegateCreateStart = codeAddr - 1;
-                    impStackTop(0);
-                }
-
                 StackEntry se   = impPopStack();
                 GenTree*   tree = se.val;
                 tiRetVal        = se.seTypeInfo;
@@ -14509,22 +14076,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 lclTyp = TYP_DOUBLE;
                 goto STIND;
             STIND:
-
-                if (tiVerificationNeeded)
-                {
-                    typeInfo instrType(lclTyp);
-#ifdef TARGET_64BIT
-                    if (opcode == CEE_STIND_I)
-                    {
-                        instrType = typeInfo::nativeInt();
-                    }
-#endif // TARGET_64BIT
-                    verVerifySTIND(impStackTop(1).seTypeInfo, impStackTop(0).seTypeInfo, instrType);
-                }
-                else
-                {
-                    compUnsafeCastUsed = true; // Have to go conservative
-                }
+                compUnsafeCastUsed = true; // Have to go conservative
 
             STIND_POST_VERIFY:
 
@@ -14550,14 +14102,12 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     //
                     if (varTypeIsI(op2->gtType) && (genActualType(lclTyp) == TYP_INT))
                     {
-                        assert(!tiVerificationNeeded); // We should have thrown the VerificationException before.
                         op2 = gtNewCastNode(TYP_INT, op2, false, TYP_INT);
                     }
                     // Allow an upcast of op2 from a 32-bit Int into TYP_I_IMPL for x86 JIT compatiblity
                     //
                     if (varTypeIsI(lclTyp) && (genActualType(op2->gtType) == TYP_INT))
                     {
-                        assert(!tiVerificationNeeded); // We should have thrown the VerificationException before.
                         op2 = gtNewCastNode(TYP_I_IMPL, op2, false, TYP_I_IMPL);
                     }
                 }
@@ -14652,23 +14202,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 lclTyp = TYP_USHORT;
                 goto LDIND;
             LDIND:
-
-                if (tiVerificationNeeded)
-                {
-                    typeInfo lclTiType(lclTyp);
-#ifdef TARGET_64BIT
-                    if (opcode == CEE_LDIND_I)
-                    {
-                        lclTiType = typeInfo::nativeInt();
-                    }
-#endif // TARGET_64BIT
-                    tiRetVal = verVerifyLDIND(impStackTop().seTypeInfo, lclTiType);
-                    tiRetVal.NormaliseForStack();
-                }
-                else
-                {
-                    compUnsafeCastUsed = true; // Have to go conservative
-                }
+                compUnsafeCastUsed = true; // Have to go conservative
 
             LDIND_POST_VERIFY:
 
@@ -14680,7 +14214,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 //
                 if (genActualType(op1->gtType) == TYP_INT)
                 {
-                    assert(!tiVerificationNeeded); // We should have thrown the VerificationException before.
                     op1 = gtNewCastNode(TYP_I_IMPL, op1, false, TYP_I_IMPL);
                 }
 #endif
@@ -14750,8 +14283,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 JITDUMP(" %08X", resolvedToken.token);
 
                 eeGetCallInfo(&resolvedToken, (prefixFlags & PREFIX_CONSTRAINED) ? &constrainedResolvedToken : nullptr,
-                              addVerifyFlag(combine(CORINFO_CALLINFO_SECURITYCHECKS, CORINFO_CALLINFO_LDFTN)),
-                              &callInfo);
+                              combine(CORINFO_CALLINFO_SECURITYCHECKS, CORINFO_CALLINFO_LDFTN), &callInfo);
 
                 // This check really only applies to intrinsic Array.Address methods
                 if (callInfo.sig.callConv & CORINFO_CALLCONV_PARAMTYPE)
@@ -14762,22 +14294,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 // Do this before DO_LDFTN since CEE_LDVIRTFN does it on its own.
                 impHandleAccessAllowed(callInfo.accessAllowed, &callInfo.callsiteCalloutHelper);
 
-                if (tiVerificationNeeded)
-                {
-                    // LDFTN could start the beginning of delegate creation sequence, remember that
-                    delegateCreateStart = codeAddr - 2;
-
-                    // check any constraints on the callee's class and type parameters
-                    VerifyOrReturn(info.compCompHnd->satisfiesClassConstraints(resolvedToken.hClass),
-                                   "method has unsatisfied class constraints");
-                    VerifyOrReturn(info.compCompHnd->satisfiesMethodConstraints(resolvedToken.hClass,
-                                                                                resolvedToken.hMethod),
-                                   "method has unsatisfied method constraints");
-
-                    mflags = callInfo.verMethodFlags;
-                    Verify(!(mflags & CORINFO_FLG_CONSTRUCTOR), "LDFTN on a constructor");
-                }
-
             DO_LDFTN:
                 op1 = impMethodPointer(&resolvedToken, &callInfo);
 
@@ -14805,8 +14321,8 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 JITDUMP(" %08X", resolvedToken.token);
 
                 eeGetCallInfo(&resolvedToken, nullptr /* constraint typeRef */,
-                              addVerifyFlag(combine(combine(CORINFO_CALLINFO_SECURITYCHECKS, CORINFO_CALLINFO_LDFTN),
-                                                    CORINFO_CALLINFO_CALLVIRT)),
+                              combine(combine(CORINFO_CALLINFO_SECURITYCHECKS, CORINFO_CALLINFO_LDFTN),
+                                      CORINFO_CALLINFO_CALLVIRT),
                               &callInfo);
 
                 // This check really only applies to intrinsic Array.Address methods
@@ -14830,40 +14346,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 CORINFO_SIG_INFO& ftnSig = callInfo.sig;
 
-                if (tiVerificationNeeded)
-                {
-
-                    Verify(ftnSig.hasThis(), "ldvirtftn on a static method");
-                    Verify(!(mflags & CORINFO_FLG_CONSTRUCTOR), "LDVIRTFTN on a constructor");
-
-                    // JIT32 verifier rejects verifiable ldvirtftn pattern
-                    typeInfo declType =
-                        verMakeTypeInfo(resolvedToken.hClass, true); // Change TI_STRUCT to TI_REF when necessary
-
-                    typeInfo arg = impStackTop().seTypeInfo;
-                    Verify((arg.IsType(TI_REF) || arg.IsType(TI_NULL)) && tiCompatibleWith(arg, declType, true),
-                           "bad ldvirtftn");
-
-                    CORINFO_CLASS_HANDLE instanceClassHnd = info.compClassHnd;
-                    if (!(arg.IsType(TI_NULL) || (mflags & CORINFO_FLG_STATIC)))
-                    {
-                        instanceClassHnd = arg.GetClassHandleForObjRef();
-                    }
-
-                    // check any constraints on the method's class and type parameters
-                    VerifyOrReturn(info.compCompHnd->satisfiesClassConstraints(resolvedToken.hClass),
-                                   "method has unsatisfied class constraints");
-                    VerifyOrReturn(info.compCompHnd->satisfiesMethodConstraints(resolvedToken.hClass,
-                                                                                resolvedToken.hMethod),
-                                   "method has unsatisfied method constraints");
-
-                    if (mflags & CORINFO_FLG_PROTECTED)
-                    {
-                        Verify(info.compCompHnd->canAccessFamily(info.compMethodHnd, instanceClassHnd),
-                               "Accessing protected method through wrong type.");
-                    }
-                }
-
                 /* Get the object-ref */
                 op1 = impPopStack().val;
                 assertImp(op1->gtType == TYP_REF);
@@ -14976,8 +14458,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 _impResolveToken(CORINFO_TOKENKIND_NewObj);
 
                 eeGetCallInfo(&resolvedToken, nullptr /* constraint typeRef*/,
-                              addVerifyFlag(combine(CORINFO_CALLINFO_SECURITYCHECKS, CORINFO_CALLINFO_ALLOWINSTPARAM)),
-                              &callInfo);
+                              combine(CORINFO_CALLINFO_SECURITYCHECKS, CORINFO_CALLINFO_ALLOWINSTPARAM), &callInfo);
 
                 if (compIsForInlining())
                 {
@@ -15011,19 +14492,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 clsFlags = callInfo.classFlags;
                 if (clsFlags & CORINFO_FLG_ARRAY)
                 {
-                    if (tiVerificationNeeded)
-                    {
-                        CORINFO_CLASS_HANDLE elemTypeHnd;
-                        INDEBUG(CorInfoType corType =)
-                        info.compCompHnd->getChildType(resolvedToken.hClass, &elemTypeHnd);
-                        assert(!(elemTypeHnd == nullptr && corType == CORINFO_TYPE_VALUECLASS));
-                        Verify(elemTypeHnd == nullptr ||
-                                   !(info.compCompHnd->getClassAttribs(elemTypeHnd) & CORINFO_FLG_BYREF_LIKE),
-                               "newarr of byref-like objects");
-                        verVerifyCall(opcode, &resolvedToken, nullptr, ((prefixFlags & PREFIX_TAILCALL_EXPLICIT) != 0),
-                                      ((prefixFlags & PREFIX_READONLY) != 0), delegateCreateStart, codeAddr - 1,
-                                      &callInfo DEBUGARG(info.compFullName));
-                    }
                     // Arrays need to call the NEWOBJ helper.
                     assertImp(clsFlags & CORINFO_FLG_VAROBJSIZE);
 
@@ -15215,10 +14683,8 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     eeGetCallInfo(&resolvedToken,
                                   (prefixFlags & PREFIX_CONSTRAINED) ? &constrainedResolvedToken : nullptr,
                                   // this is how impImportCall invokes getCallInfo
-                                  addVerifyFlag(
-                                      combine(combine(CORINFO_CALLINFO_ALLOWINSTPARAM, CORINFO_CALLINFO_SECURITYCHECKS),
-                                              (opcode == CEE_CALLVIRT) ? CORINFO_CALLINFO_CALLVIRT
-                                                                       : CORINFO_CALLINFO_NONE)),
+                                  combine(combine(CORINFO_CALLINFO_ALLOWINSTPARAM, CORINFO_CALLINFO_SECURITYCHECKS),
+                                          (opcode == CEE_CALLVIRT) ? CORINFO_CALLINFO_CALLVIRT : CORINFO_CALLINFO_NONE),
                                   &callInfo);
                 }
                 else
@@ -15359,13 +14825,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     impHandleAccessAllowed(callInfo.accessAllowed, &callInfo.callsiteCalloutHelper);
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    verVerifyCall(opcode, &resolvedToken, constraintCall ? &constrainedResolvedToken : nullptr,
-                                  explicitTailCall, readonlyCall, delegateCreateStart, codeAddr - 1,
-                                  &callInfo DEBUGARG(info.compFullName));
-                }
-
                 callTyp = impImportCall(opcode, &resolvedToken, constraintCall ? &constrainedResolvedToken : nullptr,
                                         newObjThisPtr, prefixFlags, &callInfo, opcodeOffs);
                 if (compDonotInline())
@@ -15485,45 +14944,10 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 // SkipVerification.
                 impHandleAccessAllowed(fieldInfo.accessAllowed, &fieldInfo.accessCalloutHelper);
 
-                if (tiVerificationNeeded)
+                // Raise InvalidProgramException if static load accesses non-static field
+                if (isLoadStatic && ((fieldInfo.fieldFlags & CORINFO_FLG_FIELD_STATIC) == 0))
                 {
-                    // You can also pass the unboxed struct to  LDFLD
-                    bool bAllowPlainValueTypeAsThis = false;
-                    if (opcode == CEE_LDFLD && impIsValueType(tiObj))
-                    {
-                        bAllowPlainValueTypeAsThis = true;
-                    }
-
-                    verVerifyField(&resolvedToken, fieldInfo, tiObj, isLoadAddress, bAllowPlainValueTypeAsThis);
-
-                    // If we're doing this on a heap object or from a 'safe' byref
-                    // then the result is a safe byref too
-                    if (isLoadAddress) // load address
-                    {
-                        if (fieldInfo.fieldFlags &
-                            CORINFO_FLG_FIELD_STATIC) // statics marked as safe will have permanent home
-                        {
-                            if (fieldInfo.fieldFlags & CORINFO_FLG_FIELD_SAFESTATIC_BYREF_RETURN)
-                            {
-                                tiRetVal.SetIsPermanentHomeByRef();
-                            }
-                        }
-                        else if (tiObj->IsObjRef() || tiObj->IsPermanentHomeByRef())
-                        {
-                            // ldflda of byref is safe if done on a gc object or on  a
-                            // safe byref
-                            tiRetVal.SetIsPermanentHomeByRef();
-                        }
-                    }
-                }
-                else
-                {
-                    // tiVerificationNeeded is false.
-                    // Raise InvalidProgramException if static load accesses non-static field
-                    if (isLoadStatic && ((fieldInfo.fieldFlags & CORINFO_FLG_FIELD_STATIC) == 0))
-                    {
-                        BADCODE("static access on an instance field");
-                    }
+                    BADCODE("static access on an instance field");
                 }
 
                 // We are using ldfld/a on a static field. We allow it, but need to get side-effect from obj.
@@ -15838,20 +15262,10 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 impHandleAccessAllowed(fieldInfo.accessAllowed, &fieldInfo.accessCalloutHelper);
 
-                if (tiVerificationNeeded)
+                // Raise InvalidProgramException if static store accesses non-static field
+                if (isStoreStatic && ((fieldInfo.fieldFlags & CORINFO_FLG_FIELD_STATIC) == 0))
                 {
-                    verVerifyField(&resolvedToken, fieldInfo, tiObj, true);
-                    typeInfo fieldType = verMakeTypeInfo(ciType, fieldClsHnd);
-                    Verify(tiCompatibleWith(tiVal, fieldType.NormaliseForStack(), true), "type mismatch");
-                }
-                else
-                {
-                    // tiVerificationNeed is false.
-                    // Raise InvalidProgramException if static store accesses non-static field
-                    if (isStoreStatic && ((fieldInfo.fieldFlags & CORINFO_FLG_FIELD_STATIC) == 0))
-                    {
-                        BADCODE("static access on an instance field");
-                    }
+                    BADCODE("static access on an instance field");
                 }
 
                 // We are using stfld on a static field.
@@ -16116,18 +15530,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     }
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    // As per ECMA 'numElems' specified can be either int32 or native int.
-                    Verify(impStackTop().seTypeInfo.IsIntOrNativeIntType(), "bad bound");
-
-                    CORINFO_CLASS_HANDLE elemTypeHnd;
-                    info.compCompHnd->getChildType(resolvedToken.hClass, &elemTypeHnd);
-                    Verify(elemTypeHnd == nullptr ||
-                               !(info.compCompHnd->getClassAttribs(elemTypeHnd) & CORINFO_FLG_BYREF_LIKE),
-                           "array of byref-like type");
-                }
-
                 tiRetVal = verMakeTypeInfo(resolvedToken.hClass);
 
                 accessAllowedResult =
@@ -16208,11 +15610,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
             break;
 
             case CEE_LOCALLOC:
-                if (tiVerificationNeeded)
-                {
-                    Verify(false, "bad opcode");
-                }
-
                 // We don't allow locallocs inside handlers
                 if (block->hasHndIndex())
                 {
@@ -16338,12 +15735,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     }
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(impStackTop().seTypeInfo.IsObjRef(), "obj reference needed");
-                    // Even if this is a value class, we know it is boxed.
-                    tiRetVal = typeInfo(TI_REF, resolvedToken.hClass);
-                }
                 accessAllowedResult =
                     info.compCompHnd->canAccessClass(&resolvedToken, info.compMethodHnd, &calloutHelper);
                 impHandleAccessAllowed(accessAllowedResult, &calloutHelper);
@@ -16415,13 +15806,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     return;
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(typeInfo::AreEquivalent(impStackTop().seTypeInfo, verMakeTypeInfo(impGetRefAnyClass())),
-                           "need refany");
-                    tiRetVal = verMakeTypeInfo(resolvedToken.hClass).MakeByRef();
-                }
-
                 op1 = impPopStack().val;
                 // make certain it is normalized;
                 op1 = impNormStructVal(op1, impGetRefAnyClass(), (unsigned)CHECK_SPILL_ALL);
@@ -16434,12 +15818,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
             case CEE_REFANYTYPE:
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(typeInfo::AreEquivalent(impStackTop().seTypeInfo, verMakeTypeInfo(impGetRefAnyClass())),
-                           "need refany");
-                }
-
                 op1 = impPopStack().val;
 
                 // make certain it is normalized;
@@ -16563,13 +15941,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 if (opcode == CEE_UNBOX_ANY && !eeIsValueClass(resolvedToken.hClass))
                 {
-                    if (tiVerificationNeeded)
-                    {
-                        typeInfo tiUnbox = impStackTop().seTypeInfo;
-                        Verify(tiUnbox.IsObjRef(), "bad unbox.any arg");
-                        tiRetVal = verMakeTypeInfo(resolvedToken.hClass);
-                        tiRetVal.NormaliseForStack();
-                    }
                     JITDUMP("\n Importing UNBOX.ANY(refClass) as CASTCLASS\n");
                     op1 = impPopStack().val;
                     goto CASTCLASS;
@@ -16580,19 +15951,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                 /* (non-byref) type, but here we're making the tiRetVal that is used */
                 /* for the intermediate pointer which we then transfer onto the OBJ */
                 /* instruction.  OBJ then creates the appropriate tiRetVal. */
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiUnbox = impStackTop().seTypeInfo;
-                    Verify(tiUnbox.IsObjRef(), "Bad unbox arg");
-
-                    tiRetVal = verMakeTypeInfo(resolvedToken.hClass);
-                    Verify(tiRetVal.IsValueClass(), "not value class");
-                    tiRetVal.MakeByRef();
-
-                    // We always come from an objref, so this is safe byref
-                    tiRetVal.SetIsPermanentHomeByRef();
-                    tiRetVal.SetIsReadonlyByRef();
-                }
 
                 op1 = impPopStack().val;
                 assertImp(op1->gtType == TYP_REF);
@@ -16761,7 +16119,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     }
 
                     assert(op1->gtType == TYP_BYREF);
-                    assert(!tiVerificationNeeded || tiRetVal.IsByRef());
                 }
                 else
                 {
@@ -16806,7 +16163,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                         oper = GT_OBJ;
 
                         assert(op1->gtType == TYP_BYREF);
-                        assert(!tiVerificationNeeded || tiRetVal.IsByRef());
 
                         goto OBJ;
                     }
@@ -16835,29 +16191,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 JITDUMP(" %08X", resolvedToken.token);
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiActual = impStackTop().seTypeInfo;
-                    typeInfo tiBox    = verMakeTypeInfo(resolvedToken.hClass);
-
-                    Verify(verIsBoxable(tiBox), "boxable type expected");
-
-                    // check the class constraints of the boxed type in case we are boxing an uninitialized value
-                    Verify(info.compCompHnd->satisfiesClassConstraints(resolvedToken.hClass),
-                           "boxed type has unsatisfied class constraints");
-
-                    Verify(tiCompatibleWith(tiActual, tiBox.NormaliseForStack(), true), "type mismatch");
-
-                    // Observation: the following code introduces a boxed value class on the stack, but,
-                    // according to the ECMA spec, one would simply expect: tiRetVal =
-                    // typeInfo(TI_REF,impGetObjectClass());
-
-                    // Push the result back on the stack,
-                    // even if clsHnd is a value class we want the TI_REF
-                    // we call back to the EE to get find out what hte type we should push (for nullable<T> we push T)
-                    tiRetVal = typeInfo(TI_REF, info.compCompHnd->getTypeForBox(resolvedToken.hClass));
-                }
-
                 accessAllowedResult =
                     info.compCompHnd->canAccessClass(&resolvedToken, info.compMethodHnd, &calloutHelper);
                 impHandleAccessAllowed(accessAllowedResult, &calloutHelper);
@@ -16898,11 +16231,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 JITDUMP(" %08X", resolvedToken.token);
 
-                if (tiVerificationNeeded)
-                {
-                    tiRetVal = typeInfo(TI_INT);
-                }
-
                 op1 = gtNewIconNode(info.compCompHnd->getClassSize(resolvedToken.hClass));
                 impPushOnStack(op1, tiRetVal);
                 break;
@@ -16926,13 +16254,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     }
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(impStackTop().seTypeInfo.IsObjRef(), "object ref expected");
-                    // box it
-                    tiRetVal = typeInfo(TI_REF, resolvedToken.hClass);
-                }
-
                 accessAllowedResult =
                     info.compCompHnd->canAccessClass(&resolvedToken, info.compMethodHnd, &calloutHelper);
                 impHandleAccessAllowed(accessAllowedResult, &calloutHelper);
@@ -16999,16 +16320,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
             case CEE_THROW:
 
-                if (tiVerificationNeeded)
-                {
-                    tiRetVal = impStackTop().seTypeInfo;
-                    Verify(tiRetVal.IsObjRef(), "object ref expected");
-                    if (verTrackObjCtorInitState && (verCurrentState.thisInitialized != TIS_Init))
-                    {
-                        Verify(!tiRetVal.IsThisPtr(), "throw uninitialized this");
-                    }
-                }
-
                 // Any block with a throw is rarely executed.
                 block->bbSetRunRarely();
 
@@ -17036,22 +16347,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     BADCODE("rethrow outside catch");
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(block->hasHndIndex(), "rethrow outside catch");
-                    if (block->hasHndIndex())
-                    {
-                        EHblkDsc* HBtab = ehGetDsc(block->getHndIndex());
-                        Verify(!HBtab->HasFinallyOrFaultHandler(), "rethrow in finally or fault");
-                        if (HBtab->HasFilter())
-                        {
-                            // we better be in the handler clause part, not the filter part
-                            Verify(jitIsBetween(compCurBB->bbCodeOffs, HBtab->ebdHndBegOffs(), HBtab->ebdHndEndOffs()),
-                                   "rethrow in filter");
-                        }
-                    }
-                }
-
                 /* Create the 'rethrow' helper call */
 
                 op1 = gtNewHelperCallNode(CORINFO_HELP_RETHROW, TYP_VOID);
@@ -17066,18 +16361,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 JITDUMP(" %08X", resolvedToken.token);
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiTo    = impStackTop().seTypeInfo;
-                    typeInfo tiInstr = verMakeTypeInfo(resolvedToken.hClass);
-
-                    Verify(tiTo.IsByRef(), "byref expected");
-                    Verify(!tiTo.IsReadonlyByRef(), "write to readonly byref");
-
-                    Verify(tiCompatibleWith(tiInstr, tiTo.DereferenceByRef(), false),
-                           "type operand incompatible with type of address");
-                }
-
                 op2 = gtNewIconNode(0);  // Value
                 op1 = impPopStack().val; // Dest
 
@@ -17101,11 +16384,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
             case CEE_INITBLK:
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(false, "bad opcode");
-                }
-
                 op3 = impPopStack().val; // Size
                 op2 = impPopStack().val; // Value
                 op1 = impPopStack().val; // Dst addr
@@ -17136,10 +16414,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
             case CEE_CPBLK:
 
-                if (tiVerificationNeeded)
-                {
-                    Verify(false, "bad opcode");
-                }
                 op3 = impPopStack().val; // Size
                 op2 = impPopStack().val; // Src addr
                 op1 = impPopStack().val; // Dst addr
@@ -17180,22 +16454,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 JITDUMP(" %08X", resolvedToken.token);
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiFrom  = impStackTop().seTypeInfo;
-                    typeInfo tiTo    = impStackTop(1).seTypeInfo;
-                    typeInfo tiInstr = verMakeTypeInfo(resolvedToken.hClass);
-
-                    Verify(tiFrom.IsByRef(), "expected byref source");
-                    Verify(tiTo.IsByRef(), "expected byref destination");
-
-                    Verify(tiCompatibleWith(tiFrom.DereferenceByRef(), tiInstr, false),
-                           "type of source address incompatible with type operand");
-                    Verify(!tiTo.IsReadonlyByRef(), "write to readonly byref");
-                    Verify(tiCompatibleWith(tiInstr, tiTo.DereferenceByRef(), false),
-                           "type operand incompatible with type of destination address");
-                }
-
                 if (!eeIsValueClass(resolvedToken.hClass))
                 {
                     op1 = impPopStack().val; // address to load from
@@ -17235,38 +16493,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     lclTyp = TYP_REF;
                 }
 
-                if (tiVerificationNeeded)
-                {
-
-                    typeInfo tiPtr = impStackTop(1).seTypeInfo;
-
-                    // Make sure we have a good looking byref
-                    Verify(tiPtr.IsByRef(), "pointer not byref");
-                    Verify(!tiPtr.IsReadonlyByRef(), "write to readonly byref");
-                    if (!tiPtr.IsByRef() || tiPtr.IsReadonlyByRef())
-                    {
-                        compUnsafeCastUsed = true;
-                    }
-
-                    typeInfo ptrVal = DereferenceByRef(tiPtr);
-                    typeInfo argVal = verMakeTypeInfo(resolvedToken.hClass);
-
-                    if (!tiCompatibleWith(impStackTop(0).seTypeInfo, NormaliseForStack(argVal), true))
-                    {
-                        Verify(false, "type of value incompatible with type operand");
-                        compUnsafeCastUsed = true;
-                    }
-
-                    if (!tiCompatibleWith(argVal, ptrVal, false))
-                    {
-                        Verify(false, "type operand incompatible with type of address");
-                        compUnsafeCastUsed = true;
-                    }
-                }
-                else
-                {
-                    compUnsafeCastUsed = true;
-                }
+                compUnsafeCastUsed = true;
 
                 if (lclTyp == TYP_REF)
                 {
@@ -17318,16 +16545,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
                     return;
                 }
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiPtr   = impStackTop().seTypeInfo;
-                    typeInfo tiInstr = verMakeTypeInfo(resolvedToken.hClass);
-
-                    Verify(!verIsByRefLike(tiInstr), "mkrefany of byref-like class");
-                    Verify(!tiPtr.IsReadonlyByRef(), "readonly byref used with mkrefany");
-                    Verify(typeInfo::AreEquivalent(tiPtr.DereferenceByRef(), tiInstr), "type mismatch");
-                }
-
                 accessAllowedResult =
                     info.compCompHnd->canAccessClass(&resolvedToken, info.compMethodHnd, &calloutHelper);
                 impHandleAccessAllowed(accessAllowedResult, &calloutHelper);
@@ -17357,29 +16574,7 @@ void Compiler::impImportBlockCode(BasicBlock* block)
 
                 tiRetVal = verMakeTypeInfo(resolvedToken.hClass);
 
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiPtr = impStackTop().seTypeInfo;
-
-                    // Make sure we have a byref
-                    if (!tiPtr.IsByRef())
-                    {
-                        Verify(false, "pointer not byref");
-                        compUnsafeCastUsed = true;
-                    }
-                    typeInfo tiPtrVal = DereferenceByRef(tiPtr);
-
-                    if (!tiCompatibleWith(tiPtrVal, tiRetVal, false))
-                    {
-                        Verify(false, "type of address incompatible with type operand");
-                        compUnsafeCastUsed = true;
-                    }
-                    tiRetVal.NormaliseForStack();
-                }
-                else
-                {
-                    compUnsafeCastUsed = true;
-                }
+                compUnsafeCastUsed = true;
 
                 if (eeIsValueClass(resolvedToken.hClass))
                 {
@@ -17423,13 +16618,6 @@ void Compiler::impImportBlockCode(BasicBlock* block)
             }
 
             case CEE_LDLEN:
-                if (tiVerificationNeeded)
-                {
-                    typeInfo tiArray = impStackTop().seTypeInfo;
-                    Verify(verIsSDArray(tiArray), "bad array");
-                    tiRetVal = typeInfo(TI_INT);
-                }
-
                 op1 = impPopStack().val;
                 if (opts.OptimizationEnabled())
                 {
@@ -17583,12 +16771,6 @@ void Compiler::impLoadArg(unsigned ilArgNum, IL_OFFSET offset)
 // It will be mapped to the correct lvaTable index
 void Compiler::impLoadLoc(unsigned ilLclNum, IL_OFFSET offset)
 {
-    if (tiVerificationNeeded)
-    {
-        Verify(ilLclNum < info.compMethodInfo->locals.numArgs, "bad loc num");
-        Verify(info.compInitMem, "initLocals not set");
-    }
-
     if (compIsForInlining())
     {
         if (ilLclNum >= info.compMethodInfo->locals.numArgs)
@@ -17711,25 +16893,6 @@ bool Compiler::impReturnInstruction(int prefixFlags, OPCODE& opcode)
 {
     const bool isTailCall = (prefixFlags & PREFIX_TAILCALL) != 0;
 
-    if (tiVerificationNeeded)
-    {
-        verVerifyThisPtrInitialised();
-
-        unsigned expectedStack = 0;
-        if (info.compRetType != TYP_VOID)
-        {
-            typeInfo tiVal = impStackTop().seTypeInfo;
-            typeInfo tiDeclared =
-                verMakeTypeInfo(info.compMethodInfo->args.retType, info.compMethodInfo->args.retTypeClass);
-
-            Verify(!verIsByRefLike(tiDeclared) || verIsSafeToReturnByRef(tiVal), "byref return");
-
-            Verify(tiCompatibleWith(tiVal, tiDeclared.NormaliseForStack(), true), "type mismatch");
-            expectedStack = 1;
-        }
-        Verify(verCurrentState.esStackDepth == expectedStack, "stack non-empty on return");
-    }
-
 #ifdef DEBUG
     // If we are importing an inlinee and have GC ref locals we always
     // need to have a spill temp for the return value.  This temp
@@ -18598,27 +17761,6 @@ void Compiler::impImportBlock(BasicBlock* block)
 #ifdef TARGET_64BIT
             if (genActualType(tree->gtType) == TYP_I_IMPL && lvaTable[tempNum].lvType == TYP_INT)
             {
-                if (tiVerificationNeeded && tgtBlock->bbEntryState != nullptr &&
-                    (tgtBlock->bbFlags & BBF_FAILED_VERIFICATION) == 0)
-                {
-                    // Merge the current state into the entry state of block;
-                    // the call to verMergeEntryStates must have changed
-                    // the entry state of the block by merging the int local var
-                    // and the native-int stack entry.
-                    bool changed = false;
-                    if (verMergeEntryStates(tgtBlock, &changed))
-                    {
-                        impRetypeEntryStateTemps(tgtBlock);
-                        impReimportBlockPending(tgtBlock);
-                        assert(changed);
-                    }
-                    else
-                    {
-                        tgtBlock->bbFlags |= BBF_FAILED_VERIFICATION;
-                        break;
-                    }
-                }
-
                 // Some other block in the spill clique set this to "int", but now we have "native int".
                 // Change the type and go back to re-import any blocks that used the wrong type.
                 lvaTable[tempNum].lvType = TYP_I_IMPL;
@@ -18639,22 +17781,20 @@ void Compiler::impImportBlock(BasicBlock* block)
             // imported already, we need to change the type of the local and reimport the spill clique.
             // If the 'byref' side has imported, we insert a cast from int to 'native int' to match
             // the 'byref' size.
-            if (!tiVerificationNeeded)
+            if (genActualType(tree->gtType) == TYP_BYREF && lvaTable[tempNum].lvType == TYP_INT)
             {
-                if (genActualType(tree->gtType) == TYP_BYREF && lvaTable[tempNum].lvType == TYP_INT)
-                {
-                    // Some other block in the spill clique set this to "int", but now we have "byref".
-                    // Change the type and go back to re-import any blocks that used the wrong type.
-                    lvaTable[tempNum].lvType = TYP_BYREF;
-                    reimportSpillClique      = true;
-                }
-                else if (genActualType(tree->gtType) == TYP_INT && lvaTable[tempNum].lvType == TYP_BYREF)
-                {
-                    // Spill clique has decided this should be "byref", but this block only pushes an "int".
-                    // Insert a sign-extension to "native int" so we match the clique size.
-                    verCurrentState.esStack[level].val = gtNewCastNode(TYP_I_IMPL, tree, false, TYP_I_IMPL);
-                }
+                // Some other block in the spill clique set this to "int", but now we have "byref".
+                // Change the type and go back to re-import any blocks that used the wrong type.
+                lvaTable[tempNum].lvType = TYP_BYREF;
+                reimportSpillClique      = true;
             }
+            else if (genActualType(tree->gtType) == TYP_INT && lvaTable[tempNum].lvType == TYP_BYREF)
+            {
+                // Spill clique has decided this should be "byref", but this block only pushes an "int".
+                // Insert a sign-extension to "native int" so we match the clique size.
+                verCurrentState.esStack[level].val = gtNewCastNode(TYP_I_IMPL, tree, false, TYP_I_IMPL);
+            }
+
 #endif // TARGET_64BIT
 
             if (tree->gtType == TYP_DOUBLE && lvaTable[tempNum].lvType == TYP_FLOAT)
@@ -18838,25 +17978,6 @@ void Compiler::impImportBlockPending(BasicBlock* block)
 #endif
         }
 
-        // Additionally, if we need to verify, merge the verification state.
-        if (tiVerificationNeeded)
-        {
-            // Merge the current state into the entry state of block; if this does not change the entry state
-            // by merging, do not add the block to the pending-list.
-            bool changed = false;
-            if (!verMergeEntryStates(block, &changed))
-            {
-                block->bbFlags |= BBF_FAILED_VERIFICATION;
-                addToPending = true; // We will pop it off, and check the flag set above.
-            }
-            else if (changed)
-            {
-                addToPending = true;
-
-                JITDUMP("Adding " FMT_BB " to pending set due to new merge result\n", block->bbNum);
-            }
-        }
-
         if (!addToPending)
         {
             return;
@@ -19308,16 +18429,6 @@ void Compiler::verInitCurrentState()
     verTrackObjCtorInitState        = false;
     verCurrentState.thisInitialized = TIS_Bottom;
 
-    if (tiVerificationNeeded)
-    {
-        // Track this ptr initialization
-        if (!info.compIsStatic && (info.compFlags & CORINFO_FLG_CONSTRUCTOR) && lvaTable[0].lvVerTypeInfo.IsObjRef())
-        {
-            verTrackObjCtorInitState        = true;
-            verCurrentState.thisInitialized = TIS_Uninit;
-        }
-    }
-
     // initialize stack info
 
     verCurrentState.esStackDepth = 0;
@@ -19498,22 +18609,8 @@ void Compiler::impImport()
 
         if (dsc->pdBB->bbFlags & BBF_FAILED_VERIFICATION)
         {
-
-#ifdef TARGET_64BIT
-            // On AMD64, during verification we have to match JIT64 behavior since the VM is very tighly
-            // coupled with the JIT64 IL Verification logic.  Look inside verHandleVerificationFailure
-            // method for further explanation on why we raise this exception instead of making the jitted
-            // code throw the verification exception during execution.
-            if (tiVerificationNeeded && opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IMPORT_ONLY))
-            {
-                BADCODE("Basic block marked as not verifiable");
-            }
-            else
-#endif // TARGET_64BIT
-            {
-                verConvertBBToThrowVerificationException(dsc->pdBB DEBUGARG(true));
-                impEndTreeList(dsc->pdBB);
-            }
+            verConvertBBToThrowVerificationException(dsc->pdBB DEBUGARG(true));
+            impEndTreeList(dsc->pdBB);
         }
         else
         {
@@ -19523,7 +18620,7 @@ void Compiler::impImport()
             {
                 return;
             }
-            if (compIsForImportOnly() && !tiVerificationNeeded)
+            if (compIsForImportOnly())
             {
                 return;
             }
@@ -19544,8 +18641,6 @@ void Compiler::impImport()
         block->bbFlags &= ~BBF_VISITED;
     }
 #endif
-
-    assert(!compIsForInlining() || !tiVerificationNeeded);
 }
 
 // Checks if a typeinfo (usually stored in the type stack) is a struct.
@@ -22265,7 +21360,7 @@ void Compiler::impDevirtualizeCall(GenTreeCall*            call,
 
         // Look up the new call info.
         CORINFO_CALL_INFO derivedCallInfo;
-        eeGetCallInfo(pDerivedResolvedToken, nullptr, addVerifyFlag(CORINFO_CALLINFO_ALLOWINSTPARAM), &derivedCallInfo);
+        eeGetCallInfo(pDerivedResolvedToken, nullptr, CORINFO_CALLINFO_ALLOWINSTPARAM, &derivedCallInfo);
 
         // Update the call.
         call->gtCallMoreFlags &= ~GTF_CALL_M_VIRTSTUB_REL_INDIRECT;
diff --git a/src/coreclr/jit/lclvars.cpp b/src/coreclr/jit/lclvars.cpp
index eb76cd663f287b..a1cfc61822216f 100644
--- a/src/coreclr/jit/lclvars.cpp
+++ b/src/coreclr/jit/lclvars.cpp
@@ -487,19 +487,7 @@ void Compiler::lvaInitThisPtr(InitVarDscInfo* varDscInfo)
             lvaSetClass(varDscInfo->varNum, info.compClassHnd);
         }
 
-        if (tiVerificationNeeded)
-        {
-            varDsc->lvVerTypeInfo = verMakeTypeInfo(info.compClassHnd);
-
-            if (varDsc->lvVerTypeInfo.IsValueClass())
-            {
-                varDsc->lvVerTypeInfo.MakeByRef();
-            }
-        }
-        else
-        {
-            varDsc->lvVerTypeInfo = typeInfo();
-        }
+        varDsc->lvVerTypeInfo = typeInfo();
 
         // Mark the 'this' pointer for the method
         varDsc->lvVerTypeInfo.SetIsThisPtr();
@@ -1323,48 +1311,6 @@ void Compiler::lvaInitVarDsc(LclVarDsc*              varDsc,
         compFloatingPointUsed = true;
     }
 
-    if (tiVerificationNeeded)
-    {
-        varDsc->lvVerTypeInfo = verParseArgSigToTypeInfo(varSig, varList);
-    }
-
-    if (tiVerificationNeeded)
-    {
-        if (varDsc->lvIsParam)
-        {
-            // For an incoming ValueType we better be able to have the full type information
-            // so that we can layout the parameter offsets correctly
-
-            if (varTypeIsStruct(type) && varDsc->lvVerTypeInfo.IsDead())
-            {
-                BADCODE("invalid ValueType parameter");
-            }
-
-            // For an incoming reference type we need to verify that the actual type is
-            // a reference type and not a valuetype.
-
-            if (type == TYP_REF &&
-                !(varDsc->lvVerTypeInfo.IsType(TI_REF) || varDsc->lvVerTypeInfo.IsUnboxedGenericTypeVar()))
-            {
-                BADCODE("parameter type mismatch");
-            }
-        }
-
-        // Disallow byrefs to byref like objects (ArgTypeHandle)
-        // techncally we could get away with just not setting them
-        if (varDsc->lvVerTypeInfo.IsByRef() && verIsByRefLike(DereferenceByRef(varDsc->lvVerTypeInfo)))
-        {
-            varDsc->lvVerTypeInfo = typeInfo();
-        }
-
-        // we don't want the EE to assert in lvaSetStruct on bad sigs, so change
-        // the JIT type to avoid even trying to call back
-        if (varTypeIsStruct(type) && varDsc->lvVerTypeInfo.IsDead())
-        {
-            type = TYP_VOID;
-        }
-    }
-
     if (typeHnd)
     {
         unsigned cFlags = info.compCompHnd->getClassAttribs(typeHnd);
@@ -1373,11 +1319,8 @@ void Compiler::lvaInitVarDsc(LclVarDsc*              varDsc,
         // a primitive. We will need the typeHnd to distinguish them, so we store it here.
         if ((cFlags & CORINFO_FLG_VALUECLASS) && !varTypeIsStruct(type))
         {
-            if (tiVerificationNeeded == false)
-            {
-                // printf("This is a struct that the JIT will treat as a primitive\n");
-                varDsc->lvVerTypeInfo = verMakeTypeInfo(typeHnd);
-            }
+            // printf("This is a struct that the JIT will treat as a primitive\n");
+            varDsc->lvVerTypeInfo = verMakeTypeInfo(typeHnd);
         }
 
         varDsc->lvOverlappingFields = StructHasOverlappingFields(cFlags);
@@ -1395,7 +1338,7 @@ void Compiler::lvaInitVarDsc(LclVarDsc*              varDsc,
     }
     if ((varTypeIsStruct(type)))
     {
-        lvaSetStruct(varNum, typeHnd, typeHnd != nullptr, !tiVerificationNeeded);
+        lvaSetStruct(varNum, typeHnd, typeHnd != nullptr, true);
         if (info.compIsVarArgs)
         {
             lvaSetStructUsedAsVarArg(varNum);
@@ -4113,8 +4056,8 @@ void Compiler::lvaMarkLclRefs(GenTree* tree, BasicBlock* block, Statement* stmt,
 #endif // UNIX_AMD64_ABI
 
         /* Variables must be used as the same type throughout the method */
-        noway_assert(tiVerificationNeeded || varDsc->lvType == TYP_UNDEF || tree->gtType == TYP_UNKNOWN ||
-                     allowStructs || genActualType(varDsc->TypeGet()) == genActualType(tree->gtType) ||
+        noway_assert(varDsc->lvType == TYP_UNDEF || tree->gtType == TYP_UNKNOWN || allowStructs ||
+                     genActualType(varDsc->TypeGet()) == genActualType(tree->gtType) ||
                      (tree->gtType == TYP_BYREF && varDsc->TypeGet() == TYP_I_IMPL) ||
                      (tree->gtType == TYP_I_IMPL && varDsc->TypeGet() == TYP_BYREF) || (tree->gtFlags & GTF_VAR_CAST) ||
                      (varTypeIsFloating(varDsc) && varTypeIsFloating(tree)) ||
diff --git a/src/coreclr/jit/typeinfo.cpp b/src/coreclr/jit/typeinfo.cpp
index 07809e57268a23..6bc69965d097b0 100644
--- a/src/coreclr/jit/typeinfo.cpp
+++ b/src/coreclr/jit/typeinfo.cpp
@@ -20,32 +20,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 
 bool Compiler::tiCompatibleWith(const typeInfo& child, const typeInfo& parent, bool normalisedForStack) const
 {
-#ifdef DEBUG
-#if VERBOSE_VERIFY
-    if (VERBOSE && tiVerificationNeeded)
-    {
-        printf("\n");
-        printf(TI_DUMP_PADDING);
-        printf("Verifying compatibility against types: ");
-        child.Dump();
-        printf(" and ");
-        parent.Dump();
-    }
-#endif // VERBOSE_VERIFY
-#endif // DEBUG
-
-    bool compatible = typeInfo::tiCompatibleWith(info.compCompHnd, child, parent, normalisedForStack);
-
-#ifdef DEBUG
-#if VERBOSE_VERIFY
-    if (VERBOSE && tiVerificationNeeded)
-    {
-        printf(compatible ? " [YES]" : " [NO]");
-    }
-#endif // VERBOSE_VERIFY
-#endif // DEBUG
-
-    return compatible;
+    return typeInfo::tiCompatibleWith(info.compCompHnd, child, parent, normalisedForStack);
 }
 
 bool Compiler::tiMergeCompatibleWith(const typeInfo& child, const typeInfo& parent, bool normalisedForStack) const
@@ -55,41 +30,7 @@ bool Compiler::tiMergeCompatibleWith(const typeInfo& child, const typeInfo& pare
 
 bool Compiler::tiMergeToCommonParent(typeInfo* pDest, const typeInfo* pSrc, bool* changed) const
 {
-#ifdef DEBUG
-#if VERBOSE_VERIFY
-    if (VERBOSE && tiVerificationNeeded)
-    {
-        printf("\n");
-        printf(TI_DUMP_PADDING);
-        printf("Attempting to merge types: ");
-        pDest->Dump();
-        printf(" and ");
-        pSrc->Dump();
-        printf("\n");
-    }
-#endif // VERBOSE_VERIFY
-#endif // DEBUG
-
-    bool mergeable = typeInfo::tiMergeToCommonParent(info.compCompHnd, pDest, pSrc, changed);
-
-#ifdef DEBUG
-#if VERBOSE_VERIFY
-    if (VERBOSE && tiVerificationNeeded)
-    {
-        printf(TI_DUMP_PADDING);
-        printf(mergeable ? "Merge successful" : "Couldn't merge types");
-        if (*changed)
-        {
-            assert(mergeable);
-            printf(", destination type changed to: ");
-            pDest->Dump();
-        }
-        printf("\n");
-    }
-#endif // VERBOSE_VERIFY
-#endif // DEBUG
-
-    return mergeable;
+    return typeInfo::tiMergeToCommonParent(info.compCompHnd, pDest, pSrc, changed);
 }
 
 static bool tiCompatibleWithByRef(COMP_HANDLE CompHnd, const typeInfo& child, const typeInfo& parent)

From 47052077b76a55a94b188b17943845ecb12d9f78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Fri, 28 Jan 2022 12:40:55 +0900
Subject: [PATCH 134/161] Add support for byref fields in NativeAOT/crossgen2
 (#64366)

The only necessary changes at this point were in code shared between crossgen2 and NativeAOT.
---
 .../Common/MetadataFieldLayoutAlgorithm.cs           | 12 ++++--------
 .../Loader/classloader/RefFields/InvalidCSharp.il    |  6 +++---
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs b/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs
index 9973be45ff1308..637f1f7538ff88 100644
--- a/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs
+++ b/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs
@@ -37,12 +37,8 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp
 
                 TypeDesc fieldType = field.FieldType;
 
-                // ByRef instance fields are not allowed.
-                if (fieldType.IsByRef)
-                    ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadGeneral, type);
-
-                // ByRef-like instance fields on non-byref-like types are not allowed.
-                if (fieldType.IsByRefLike && !type.IsByRefLike)
+                // ByRef and byref-like instance fields on non-byref-like types are not allowed.
+                if ((fieldType.IsByRef || fieldType.IsByRefLike) && !type.IsByRefLike)
                     ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadGeneral, type);
 
                 numInstanceFields++;
@@ -481,7 +477,7 @@ protected ComputedInstanceFieldLayout ComputeAutoFieldLayout(MetadataType type,
                 }
                 else
                 {
-                    Debug.Assert(fieldType.IsPrimitive || fieldType.IsPointer || fieldType.IsFunctionPointer || fieldType.IsEnum);
+                    Debug.Assert(fieldType.IsPrimitive || fieldType.IsPointer || fieldType.IsFunctionPointer || fieldType.IsEnum || fieldType.IsByRef);
 
                     var fieldSizeAndAlignment = ComputeFieldSizeAndAlignment(fieldType, hasLayout, packingSize, out bool _, out bool _);
                     instanceNonGCPointerFieldsCount[CalculateLog2(fieldSizeAndAlignment.Size.AsInt)]++;
@@ -815,7 +811,7 @@ private static SizeAndAlignment ComputeFieldSizeAndAlignment(TypeDesc fieldType,
             }
             else
             {
-                Debug.Assert(fieldType.IsPointer || fieldType.IsFunctionPointer);
+                Debug.Assert(fieldType.IsPointer || fieldType.IsFunctionPointer || fieldType.IsByRef);
                 result.Size = fieldType.Context.Target.LayoutPointerSize;
                 result.Alignment = fieldType.Context.Target.LayoutPointerSize;
             }
diff --git a/src/tests/Loader/classloader/RefFields/InvalidCSharp.il b/src/tests/Loader/classloader/RefFields/InvalidCSharp.il
index b976227547def5..7fc74717dd1029 100644
--- a/src/tests/Loader/classloader/RefFields/InvalidCSharp.il
+++ b/src/tests/Loader/classloader/RefFields/InvalidCSharp.il
@@ -107,7 +107,7 @@
         ldarg.0
         ldarga.s 1
         mkrefany !T
-        stfld typedref InvalidCSharp.WithTypedReferenceField`1::Field
+        stfld typedref valuetype InvalidCSharp.WithTypedReferenceField`1<!T>::Field
         ret
     }
 
@@ -115,9 +115,9 @@
         instance class [System.Runtime]System.Type GetFieldType () cil managed
     {
         ldarg.0
-        ldfld typedref InvalidCSharp.WithTypedReferenceField`1::Field
+        ldfld typedref valuetype InvalidCSharp.WithTypedReferenceField`1<!T>::Field
         refanytype
         call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle )
         ret
     }
-}
\ No newline at end of file
+}

From 953fd351ae1c5c8c11ba865b3613b63f8f774624 Mon Sep 17 00:00:00 2001
From: Tomas Weinfurt <tweinfurt@yahoo.com>
Date: Thu, 27 Jan 2022 23:03:31 -0800
Subject: [PATCH 135/161] fix ping with SendIpHeader on FreeBSD (#63531)

* fix ping with SendIpHeader on FreeBSD

* update to fix command line and DF

* add comment
---
 .../Net/NetworkInformation/UnixCommandLinePing.cs |  6 ++++--
 .../Net/NetworkInformation/Ping.RawSocket.cs      | 15 +++++++++------
 .../System/Net/NetworkInformation/Ping.Unix.cs    |  2 +-
 .../tests/FunctionalTests/TestSettings.cs         |  4 +++-
 4 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/libraries/Common/src/System/Net/NetworkInformation/UnixCommandLinePing.cs b/src/libraries/Common/src/System/Net/NetworkInformation/UnixCommandLinePing.cs
index 579e69a153f045..c2fcca169d21dc 100644
--- a/src/libraries/Common/src/System/Net/NetworkInformation/UnixCommandLinePing.cs
+++ b/src/libraries/Common/src/System/Net/NetworkInformation/UnixCommandLinePing.cs
@@ -90,7 +90,8 @@ public static string ConstructCommandLine(int packetSize, int timeout, string ad
             // OSX: ping requires -W flag which accepts timeout in MILLISECONDS; ping6 doesn't support timeout
             if (OperatingSystem.IsFreeBSD())
             {
-                if (ipv4)
+                // Syntax changed in FreeBSD 13.0 and options are not common for both address families
+                if (ipv4 || Environment.OSVersion.Version.Major > 12)
                 {
                     sb.Append(" -W ");
                 }
@@ -135,7 +136,8 @@ public static string ConstructCommandLine(int packetSize, int timeout, string ad
                 if (OperatingSystem.IsFreeBSD() || OperatingSystem.IsMacOS())
                 {
                     // OSX and FreeBSD use -h to set hop limit for IPv6 and -m ttl for IPv4
-                    if (ipv4)
+                    // Syntax changed in FreeBSD 13.0 and options are not common for both address families
+                    if (ipv4 || (OperatingSystem.IsFreeBSD() && Environment.OSVersion.Version.Major > 12))
                     {
                         sb.Append(" -m ");
                     }
diff --git a/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.RawSocket.cs b/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.RawSocket.cs
index 0d81532f2bc144..94cdeb2fe890c6 100644
--- a/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.RawSocket.cs
+++ b/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.RawSocket.cs
@@ -19,6 +19,7 @@ public partial class Ping
         private const int MinIpHeaderLengthInBytes = 20;
         private const int MaxIpHeaderLengthInBytes = 60;
         private const int IpV6HeaderLengthInBytes = 40;
+        private static ushort DontFragment = OperatingSystem.IsFreeBSD() ? (ushort)IPAddress.HostToNetworkOrder((short)0x4000) : (ushort)0x4000;
 
         private unsafe SocketConfig GetSocketConfig(IPAddress address, byte[] buffer, int timeout, PingOptions? options)
         {
@@ -29,15 +30,17 @@ private unsafe SocketConfig GetSocketConfig(IPAddress address, byte[] buffer, in
 
             bool ipv4 = address.AddressFamily == AddressFamily.InterNetwork;
             bool sendIpHeader = ipv4 && options != null && SendIpHeader;
+            int totalLength = 0;
 
              if (sendIpHeader)
              {
                 iph.VersionAndLength = 0x45;
+                totalLength = sizeof(IpHeader) + checked(sizeof(IcmpHeader) +  buffer.Length);
                 // On OSX this strangely must be host byte order.
-                iph.TotalLength = (ushort)(sizeof(IpHeader) + checked(sizeof(IcmpHeader) +  buffer.Length));
+                iph.TotalLength = OperatingSystem.IsFreeBSD() ? (ushort)IPAddress.HostToNetworkOrder((short)totalLength) : (ushort)totalLength;
                 iph.Protocol = 1; // ICMP
                 iph.Ttl = (byte)options!.Ttl;
-                iph.Flags = (ushort)(options.DontFragment ? 0x4000 : 0);
+                iph.Flags = (ushort)(options.DontFragment ? DontFragment : 0);
 #pragma warning disable 618
                 iph.DestinationAddress = (uint)address.Address;
 #pragma warning restore 618
@@ -52,7 +55,7 @@ private unsafe SocketConfig GetSocketConfig(IPAddress address, byte[] buffer, in
                 {
                     Type = ipv4 ? (byte)IcmpV4MessageType.EchoRequest : (byte)IcmpV6MessageType.EchoRequest,
                     Identifier = id,
-                }, buffer));
+                }, buffer, totalLength));
         }
 
         private Socket GetRawSocket(SocketConfig socketConfig)
@@ -405,14 +408,14 @@ public SocketConfig(EndPoint endPoint, int timeout, PingOptions? options, bool i
             public readonly byte[] SendBuffer;
         }
 
-        private static unsafe byte[] CreateSendMessageBuffer(IpHeader ipHeader, IcmpHeader icmpHeader, byte[] payload)
+        private static unsafe byte[] CreateSendMessageBuffer(IpHeader ipHeader, IcmpHeader icmpHeader, byte[] payload, int totalLength = 0)
         {
             int icmpHeaderSize = sizeof(IcmpHeader);
             int offset = 0;
-            int packetSize = ipHeader.TotalLength != 0 ? ipHeader.TotalLength : checked(icmpHeaderSize + payload.Length);
+            int packetSize = totalLength != 0 ? totalLength : checked(icmpHeaderSize + payload.Length);
             byte[] result = new byte[packetSize];
 
-            if (ipHeader.TotalLength != 0)
+            if (totalLength != 0)
             {
                 int ipHeaderSize = sizeof(IpHeader);
                 new Span<byte>(&ipHeader, sizeof(IpHeader)).CopyTo(result);
diff --git a/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.Unix.cs b/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.Unix.cs
index 3897853f6d856f..987d0462d70cae 100644
--- a/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.Unix.cs
+++ b/src/libraries/System.Net.Ping/src/System/Net/NetworkInformation/Ping.Unix.cs
@@ -15,7 +15,7 @@ namespace System.Net.NetworkInformation
 {
     public partial class Ping
     {
-        private static bool SendIpHeader => false;
+        private static bool SendIpHeader => OperatingSystem.IsFreeBSD();
         private static bool NeedsConnect => OperatingSystem.IsLinux();
         private static bool SupportsDualMode => true;
 
diff --git a/src/libraries/System.Net.Ping/tests/FunctionalTests/TestSettings.cs b/src/libraries/System.Net.Ping/tests/FunctionalTests/TestSettings.cs
index a36d4f93deb02b..8a87d2f0111e67 100644
--- a/src/libraries/System.Net.Ping/tests/FunctionalTests/TestSettings.cs
+++ b/src/libraries/System.Net.Ping/tests/FunctionalTests/TestSettings.cs
@@ -14,7 +14,9 @@ internal static class TestSettings
         public const int PingTimeout = 10 * 1000;
 
         public const string PayloadAsString = "'Post hoc ergo propter hoc'. 'After it, therefore because of it'. It means one thing follows the other, therefore it was caused by the other. But it's not always true. In fact it's hardly ever true.";
-        public static readonly byte[] PayloadAsBytes = Encoding.UTF8.GetBytes(TestSettings.PayloadAsString);
+
+        // By default, FreeBSD supports buffer only up to 56 bytes
+        public static readonly byte[] PayloadAsBytes = Encoding.UTF8.GetBytes(OperatingSystem.IsFreeBSD() ? TestSettings.PayloadAsString.Substring(0, 55) : TestSettings.PayloadAsString);
 
         public static readonly byte[] PayloadAsBytesShort = Encoding.UTF8.GetBytes("ABCDEF0123456789");
 

From 11bf8a782d27dd0f614dd0da03b27ab025933320 Mon Sep 17 00:00:00 2001
From: Radek Zikmund <32671551+rzikm@users.noreply.github.com>
Date: Fri, 28 Jan 2022 10:02:40 +0100
Subject: [PATCH 136/161] Throw during renegotiation if there is incomplete
 received TLS frame (#64066)

We need to check both if there is unread data from previous TLS frame, or if there is incomplete incoming TLS frame
---
 .../tests/System/Net/ManualChunkingStream.cs  | 103 ++++++++++++++
 .../Net/Security/SslStream.Implementation.cs  |   2 +-
 .../SslStreamNetworkStreamTest.cs             | 130 +++++++++++-------
 .../System.Net.Security.Tests.csproj          |   2 +
 4 files changed, 183 insertions(+), 54 deletions(-)
 create mode 100644 src/libraries/Common/tests/System/Net/ManualChunkingStream.cs

diff --git a/src/libraries/Common/tests/System/Net/ManualChunkingStream.cs b/src/libraries/Common/tests/System/Net/ManualChunkingStream.cs
new file mode 100644
index 00000000000000..a37fb304bb9a15
--- /dev/null
+++ b/src/libraries/Common/tests/System/Net/ManualChunkingStream.cs
@@ -0,0 +1,103 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Net.Test.Common
+{
+    // Wrapper stream to manually chop writes. This can be useful for simulating partial network transfers
+    public class ManualChunkingStream : Stream
+    {
+        private readonly Stream _innerStream;
+        private readonly StreamBuffer _writeBuffer = new StreamBuffer();
+        private bool _chunkWrite;
+
+        public ManualChunkingStream(Stream stream, bool chunkWrite)
+        {
+            _innerStream = stream;
+            _chunkWrite = chunkWrite;
+        }
+
+        public int PendingWriteLength => _writeBuffer.ReadBytesAvailable;
+
+        public async ValueTask CommitWriteAsync(int length)
+        {
+            Debug.Assert(length <= PendingWriteLength && length > 0, "length <= PendingWriteLength && length > 0");
+            byte[] buffer = ArrayPool<byte>.Shared.Rent(length);
+
+            int read = await _writeBuffer.ReadAsync(buffer.AsMemory(0, length));
+            Debug.Assert(read == length, "read == length");
+            await _innerStream.WriteAsync(buffer, 0, read);
+            await _innerStream.FlushAsync();
+
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+
+        public void SetWriteChunking(bool chunking)
+        {
+            _chunkWrite = chunking;
+            if (!_chunkWrite && PendingWriteLength > 0)
+            {
+                // flush pending writes
+                byte[] buffer = ArrayPool<byte>.Shared.Rent(PendingWriteLength);
+
+                int read = _writeBuffer.Read(buffer.AsSpan(0, PendingWriteLength));
+                Debug.Assert(PendingWriteLength == 0, "PendingWriteLength == 0");
+                _innerStream.Write(buffer, 0, read);
+                _innerStream.Flush();
+
+                ArrayPool<byte>.Shared.Return(buffer);
+            }
+        }
+
+        public override bool CanSeek => _innerStream.CanSeek;
+
+        public override bool CanRead => _innerStream.CanRead;
+
+        public override bool CanTimeout => _innerStream.CanTimeout;
+
+        public override bool CanWrite => _innerStream.CanWrite;
+
+        public override long Position
+        {
+            get => _innerStream.Position;
+            set => _innerStream.Position = value;
+        }
+
+        public override void SetLength(long value) => _innerStream.SetLength(value);
+
+        public override long Length => _innerStream.Length;
+
+        public override void Flush() => _innerStream.Flush();
+
+        public override Task FlushAsync(CancellationToken cancellationToken) => _innerStream.FlushAsync(cancellationToken);
+
+        public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
+
+        public override int Read(byte[] buffer, int offset, int count) => Read(new Span<byte>(buffer, offset, count));
+
+        public override int Read(Span<byte> buffer) => _innerStream.Read(buffer);
+
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => ReadAsync(new Memory<byte>(buffer, offset, count)).AsTask();
+
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) => _innerStream.ReadAsync(buffer, cancellationToken);
+
+        public override void Write(byte[] buffer, int offset, int count) => Write(new ReadOnlySpan<byte>(buffer, offset, count));
+
+        public override void Write(ReadOnlySpan<byte> buffer)
+        {
+            if (_chunkWrite)
+                _writeBuffer.Write(buffer);
+            else
+                _innerStream.Write(buffer);
+        }
+
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count)).AsTask();
+
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) => _chunkWrite ? _writeBuffer.WriteAsync(buffer, cancellationToken) : _innerStream.WriteAsync(buffer, cancellationToken);
+    }
+}
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs
index 9e6ad7475d7663..34550835ead047 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs
@@ -270,7 +270,7 @@ private async Task RenegotiateAsync<TIOAdapter>(TIOAdapter adapter)
 
             try
             {
-                if (_decryptedBytesCount is not 0)
+                if ((_decryptedBytesCount | _internalBufferCount) != 0)
                 {
                     throw new InvalidOperationException(SR.net_ssl_renegotiate_buffer);
                 }
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs b/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs
index ce44c047929797..aec32cd84a418a 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/SslStreamNetworkStreamTest.cs
@@ -352,21 +352,25 @@ await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
 
                 // Send application data instead of Client hello.
                 await client.WriteAsync(new byte[500], cts.Token);
-                // Fail as it is not allowed to receive non hnadshake frames during handshake.
+                // Fail as it is not allowed to receive non handshake frames during handshake.
                 await Assert.ThrowsAsync<InvalidOperationException>(()=> t);
             }
         }
 
         [ConditionalFact(nameof(SupportsRenegotiation))]
         [PlatformSpecific(TestPlatforms.Windows | TestPlatforms.Linux)]
-        public async Task SslStream_NegotiateClientCertificateAsync_ServerDontDrainClientData()
+        public async Task SslStream_NegotiateClientCertificateAsync_IncompleteIncomingTlsFrame_Throws()
         {
             using CancellationTokenSource cts = new CancellationTokenSource();
             cts.CancelAfter(TestConfiguration.PassingTestTimeout);
 
-            (SslStream client, SslStream server) = TestHelper.GetConnectedSslStreams();
-            using (client)
-            using (server)
+            (Stream clientStream, Stream serverStream) = TestHelper.GetConnectedStreams();
+
+            // use ManualChunkingStream in the middle to enforce partial TLS frame receive later
+            ManualChunkingStream clientChunkingStream = new ManualChunkingStream(clientStream, false);
+
+            using (SslStream server = new SslStream(serverStream))
+            using (SslStream client = new SslStream(clientChunkingStream))
             {
                 using X509Certificate2 serverCertificate = Configuration.Certificates.GetServerCertificate();
                 using X509Certificate2 clientCertificate = Configuration.Certificates.GetClientCertificate();
@@ -386,26 +390,86 @@ public async Task SslStream_NegotiateClientCertificateAsync_ServerDontDrainClien
                 await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
                                 client.AuthenticateAsClientAsync(clientOptions, cts.Token),
                                 server.AuthenticateAsServerAsync(serverOptions, cts.Token));
-
                 Assert.Null(server.RemoteCertificate);
 
-                // Send application data instead of Client hello.
-                await client.WriteAsync(new byte[500], cts.Token);
-                // Server don't drain the client data
-                await server.ReadAsync(new byte[1]);
-                // Fail as it is not allowed to receive non hnadshake frames during handshake.
+                // manually approve all future writes
+                clientChunkingStream.SetWriteChunking(true);
+
+                // TLS packets are maximum 16 kB, sending 20 kB of data guarantees at least 2 packets to be sent
+                byte[] buffer = new byte[20 * 1024];
+                client.Write(buffer);
+
+                // delay receiving last few B so that only an incomplete TLS frame is received
+                await clientChunkingStream.CommitWriteAsync(clientChunkingStream.PendingWriteLength - 100);
+                int read = await server.ReadAsync(buffer, cts.Token);
+
+                // Fail as there are still some undrained data (incomplete incoming TLS frame)
                 await Assert.ThrowsAsync<InvalidOperationException>(()=>
                     server.NegotiateClientCertificateAsync(cts.Token)
                 );
 
-                // Drain client data.
-                await server.ReadAsync(new byte[499]);
+                // no more delaying needed, drain client data.
+                clientChunkingStream.SetWriteChunking(false);
+                while (read < buffer.Length)
+                {
+                    read += await server.ReadAsync(buffer);
+                }
+
                 // Verify that the session is usable even renego request failed.
                 await TestHelper.PingPong(client, server, cts.Token);
                 await TestHelper.PingPong(server, client, cts.Token);
             }
         }
 
+        [ConditionalFact(nameof(SupportsRenegotiation))]
+        [PlatformSpecific(TestPlatforms.Windows | TestPlatforms.Linux)]
+        public async Task SslStream_NegotiateClientCertificateAsync_PendingDecryptedData_Throws()
+        {
+            using CancellationTokenSource cts = new CancellationTokenSource();
+            cts.CancelAfter(TestConfiguration.PassingTestTimeout);
+
+            (SslStream client, SslStream server) = TestHelper.GetConnectedSslStreams();
+            using (client)
+            using (server)
+            {
+                using X509Certificate2 serverCertificate = Configuration.Certificates.GetServerCertificate();
+                using X509Certificate2 clientCertificate = Configuration.Certificates.GetClientCertificate();
+
+                SslClientAuthenticationOptions clientOptions = new SslClientAuthenticationOptions()
+                {
+                    TargetHost = Guid.NewGuid().ToString("N"),
+                    ClientCertificates = new X509CertificateCollection(new X509Certificate2[] { clientCertificate })
+                };
+                clientOptions.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
+
+                SslServerAuthenticationOptions serverOptions = new SslServerAuthenticationOptions() { ServerCertificate = serverCertificate };
+                serverOptions.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
+
+                await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
+                                client.AuthenticateAsClientAsync(clientOptions, cts.Token),
+                                server.AuthenticateAsServerAsync(serverOptions, cts.Token));
+
+                await TestHelper.PingPong(client, server, cts.Token);
+                Assert.Null(server.RemoteCertificate);
+
+                // This should go out in single TLS frame
+                await client.WriteAsync(new byte[200], cts.Token);
+                byte[] readBuffer = new byte[10];
+                // when we read part of the frame, remaining part should left decrypted
+                int read = await server.ReadAsync(readBuffer, cts.Token);
+
+                await Assert.ThrowsAsync<InvalidOperationException>(() => server.NegotiateClientCertificateAsync(cts.Token));
+
+                while (read < 200)
+                {
+                    read += await server.ReadAsync(readBuffer, cts.Token);
+                }
+
+                // verify that the session is usable with or without client's certificate
+                await TestHelper.PingPong(client, server, cts.Token);
+                await TestHelper.PingPong(server, client, cts.Token);
+            }
+        }
 
         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.SupportsTls13))]
         [InlineData(true)]
@@ -587,46 +651,6 @@ await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
             }
         }
 
-        [Fact]
-        [PlatformSpecific(TestPlatforms.Windows)]
-        public async Task NegotiateClientCertificateAsync_PendingData_Throws()
-        {
-            using CancellationTokenSource cts = new CancellationTokenSource();
-            cts.CancelAfter(TestConfiguration.PassingTestTimeout);
-
-            (SslStream client, SslStream server) = TestHelper.GetConnectedSslStreams();
-            using (client)
-            using (server)
-            using (X509Certificate2 serverCertificate = Configuration.Certificates.GetServerCertificate())
-            using (X509Certificate2 clientCertificate = Configuration.Certificates.GetClientCertificate())
-            {
-                SslClientAuthenticationOptions clientOptions = new SslClientAuthenticationOptions()
-                {
-                    TargetHost = Guid.NewGuid().ToString("N"),
-                    ClientCertificates = new X509CertificateCollection(new X509Certificate2[] { clientCertificate })
-                };
-                clientOptions.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
-
-                SslServerAuthenticationOptions serverOptions = new SslServerAuthenticationOptions() { ServerCertificate = serverCertificate };
-                serverOptions.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
-
-                await TestConfiguration.WhenAllOrAnyFailedWithTimeout(
-                                client.AuthenticateAsClientAsync(clientOptions, cts.Token),
-                                server.AuthenticateAsServerAsync(serverOptions, cts.Token));
-
-                await TestHelper.PingPong(client, server, cts.Token);
-                Assert.Null(server.RemoteCertificate);
-
-                // This should go out in single TLS frame
-                await client.WriteAsync(new byte[200], cts.Token);
-                byte[] readBuffer = new byte[10];
-                // when we read part of the frame, remaining part should left decrypted
-                await server.ReadAsync(readBuffer, cts.Token);
-
-                await Assert.ThrowsAsync<InvalidOperationException>(() => server.NegotiateClientCertificateAsync(cts.Token));
-            }
-        }
-
         [Fact]
         public async Task SslStream_NestedAuth_Throws()
         {
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj b/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj
index ea97df3db286a6..72ef0e0c581326 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj
@@ -53,6 +53,8 @@
              Link="Common\System\Net\SslStreamCertificatePolicy.cs" />
     <Compile Include="$(CommonTestPath)System\Net\RandomReadWriteSizeStream.cs"
              Link="Common\System\Net\RandomReadWriteSizeStream.cs" />
+    <Compile Include="$(CommonTestPath)System\Net\ManualChunkingStream.cs"
+             Link="Common\System\Net\ManualChunkingStream.cs" />
     <Compile Include="$(CommonTestPath)System\Net\Configuration.cs"
              Link="Common\System\Net\Configuration.cs" />
     <Compile Include="$(CommonTestPath)System\Net\Configuration.Security.cs"

From 052e24110f232f9abd6a5e5d4cb4a610dc20c237 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Fri, 28 Jan 2022 12:22:41 +0100
Subject: [PATCH 137/161] AltTrailingSlash tests should actually use
 AltDirectorySeparatorChar (#64437)

---
 src/libraries/System.IO.FileSystem/tests/File/Exists.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/libraries/System.IO.FileSystem/tests/File/Exists.cs b/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
index 811df24f9e741f..9828ea7524a0e4 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
@@ -79,7 +79,7 @@ public void PathEndsInTrailingSlash()
         [PlatformSpecific(TestPlatforms.Windows)]
         public void PathEndsInAltTrailingSlash_Windows()
         {
-            string path = GetTestFilePath() + Path.DirectorySeparatorChar;
+            string path = GetTestFilePath() + Path.AltDirectorySeparatorChar;
             Assert.False(Exists(path));
         }
 
@@ -97,7 +97,7 @@ public void PathEndsInAltTrailingSlash_AndExists_Windows()
         {
             string path = GetTestFilePath();
             File.Create(path).Dispose();
-            Assert.False(Exists(path + Path.DirectorySeparatorChar));
+            Assert.False(Exists(path + Path.AltDirectorySeparatorChar));
         }
 
         [Fact]

From b4147e66c9c8f816c6764c9de9926150d4f68a22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Fri, 28 Jan 2022 21:09:14 +0900
Subject: [PATCH 138/161] Remove Native AOT pointer to runtimelab (#64429)

---
 docs/project/glossary.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/project/glossary.md b/docs/project/glossary.md
index 9104049e947ec1..28fed9e8e160d5 100644
--- a/docs/project/glossary.md
+++ b/docs/project/glossary.md
@@ -187,8 +187,7 @@ by Mono runtime in environments that allow fallback to JIT or need IL interprete
 
 [Native AOT](https://github.com/dotnet/designs/blob/main/accepted/2020/form-factors.md#native-aot-form-factors) is
 a .NET runtime form factor with key performance characteristics (startup time, binary size and steady state throughput and predictability)
-competitive with statically compiled languages. A .NET runtime flavor based on CoreCLR with these characteristics is being developed as
-experimental project in [dotnet/runtimelab](https://github.com/dotnet/runtimelab/tree/feature/NativeAOT) repo.
+competitive with statically compiled languages.
 
 ## Frameworks
 

From 88b63d18451689202222fcbff5984bbf68ee1114 Mon Sep 17 00:00:00 2001
From: Adeel Mujahid <3840695+am11@users.noreply.github.com>
Date: Fri, 28 Jan 2022 14:23:58 +0200
Subject: [PATCH 139/161] Delete null comparisons of non-null arguments
 (#64435)

---
 src/coreclr/nativeaot/Runtime/DebugHeader.cpp | 4 ++--
 src/coreclr/nativeaot/Runtime/MethodTable.cpp | 4 ----
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/coreclr/nativeaot/Runtime/DebugHeader.cpp b/src/coreclr/nativeaot/Runtime/DebugHeader.cpp
index 76b603906cf7ca..991f67bb9b2274 100644
--- a/src/coreclr/nativeaot/Runtime/DebugHeader.cpp
+++ b/src/coreclr/nativeaot/Runtime/DebugHeader.cpp
@@ -139,8 +139,8 @@ extern "C" void PopulateDebugHeaders()
     size_t currentDebugPos = 0;
     size_t currentGlobalPos = 0;
 
-    ZeroMemory(s_DebugEntries, DebugTypeEntriesArraySize);
-    ZeroMemory(s_GlobalEntries, GlobalEntriesArraySize);
+    ZeroMemory(s_DebugEntries, sizeof(s_DebugEntries));
+    ZeroMemory(s_GlobalEntries, sizeof(s_GlobalEntries));
 
     MAKE_SIZE_ENTRY(GcDacVars);
     MAKE_DEBUG_FIELD_ENTRY(GcDacVars, major_version_number);
diff --git a/src/coreclr/nativeaot/Runtime/MethodTable.cpp b/src/coreclr/nativeaot/Runtime/MethodTable.cpp
index 4197cd8ba36237..4d3ace8dcf089a 100644
--- a/src/coreclr/nativeaot/Runtime/MethodTable.cpp
+++ b/src/coreclr/nativeaot/Runtime/MethodTable.cpp
@@ -20,10 +20,6 @@ bool MethodTable::Validate(bool assertOnFail /* default: true */)
 {
 #define REPORT_FAILURE() do { if (assertOnFail) { ASSERT_UNCONDITIONALLY("MethodTable::Validate check failed"); } return false; } while (false)
 
-    // Deal with the most common case of a bad pointer without an exception.
-    if (this == NULL)
-        REPORT_FAILURE();
-
     // MethodTable structures should be at least pointer aligned.
     if (dac_cast<TADDR>(this) & (sizeof(TADDR)-1))
         REPORT_FAILURE();

From e824d399a65a7a4e644d790e701f218503c38e34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Fri, 28 Jan 2022 21:26:43 +0900
Subject: [PATCH 140/161] Fix NativeAOT official build (#64432)

Official builds are currently not building NativeAOT CoreLib.

For unknown reasons the official build splits native build and managed build of the CoreCLR partition.

We had a convenient clr.nativeaotlibs subset that built both the native part and managed part. Managed part can't be built without the native part, so it makes sense.

To satisfy official build's weirdness, we need to split this into two subsets so that we can tell the official build to build the managed part. (Official builds already build everything in the native part, so we're good there.)
---
 docs/workflow/building/coreclr/nativeaot.md   | 2 +-
 eng/Subsets.props                             | 5 +++--
 eng/pipelines/coreclr/templates/build-job.yml | 2 +-
 eng/pipelines/runtime.yml                     | 6 +++---
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/docs/workflow/building/coreclr/nativeaot.md b/docs/workflow/building/coreclr/nativeaot.md
index 968bb5fa892435..3206fc7349c200 100644
--- a/docs/workflow/building/coreclr/nativeaot.md
+++ b/docs/workflow/building/coreclr/nativeaot.md
@@ -21,7 +21,7 @@ The executable looks like a native executable, in the sense that it can be debug
 ## Building
 
 - [Install pre-requisites](../../README.md#build-requirements)
-- Run `build[.cmd|.sh] clr+libs -rc [Debug|Release] -lc Release` from the repo root. This will restore nuget packages required for building and build the parts of the repo required for general CoreCLR development. Alternatively, instead of specifying `clr+libs`, you can specify `clr.jit+clr.tools+clr.nativeaotlibs+libs` which is more targeted and builds faster. Replace `clr.jit` with `clr.alljits` if you need to crosscompile.
+- Run `build[.cmd|.sh] clr+libs -rc [Debug|Release] -lc Release` from the repo root. This will restore nuget packages required for building and build the parts of the repo required for general CoreCLR development. Alternatively, instead of specifying `clr+libs`, you can specify `clr.jit+clr.tools+clr.nativeaotlibs+clr.nativeaotruntime+libs` which is more targeted and builds faster. Replace `clr.jit` with `clr.alljits` if you need to crosscompile.
 - [NOT PORTED OVER YET] The build will place the toolchain packages at `artifacts\packages\[Debug|Release]\Shipping`. To publish your project using these packages:
    - [NOT PORTED OVER YET] Add the package directory to your `nuget.config` file. For example, replace `dotnet-experimental` line in `samples\HelloWorld\nuget.config` with `<add key="local" value="C:\runtimelab\artifacts\packages\Debug\Shipping" />`
    - [NOT PORTED OVER YET] Run `dotnet publish --packages pkg -r [win-x64|linux-x64|osx-64] -c [Debug|Release]` to publish your project. `--packages pkg` option restores the package into a local directory that is easy to cleanup once you are done. It avoids polluting the global nuget cache with your locally built dev package.
diff --git a/eng/Subsets.props b/eng/Subsets.props
index 4fc54cfd823d15..5ea1ff48e23f4a 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -106,7 +106,8 @@
     <SubsetName Include="Clr.ILTools" Description="The CoreCLR IL tools." />
     <SubsetName Include="Clr.Runtime" Description="The CoreCLR .NET runtime." />
     <SubsetName Include="Clr.Native" Description="All CoreCLR native non-test components, including the runtime, jits, and other native tools." />
-    <SubsetName Include="Clr.NativeAotLibs" Description="The CoreCLR native AOT CoreLib, runtime, and other low level class libraries." />
+    <SubsetName Include="Clr.NativeAotLibs" Description="The CoreCLR native AOT CoreLib and other low level class libraries." />
+    <SubsetName Include="Clr.NativeAotRuntime" Description="The stripped-down CoreCLR native AOT runtime." />
     <SubsetName Include="Clr.PalTests" OnDemand="true" Description="The CoreCLR PAL tests." />
     <SubsetName Include="Clr.PalTestList" OnDemand="true" Description="Generate the list of the CoreCLR PAL tests. When using the command line, use Clr.PalTests instead." />
     <SubsetName Include="Clr.Hosts" Description="The CoreCLR corerun test host." />
@@ -203,7 +204,7 @@
     <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrILToolsSubset=true</ClrRuntimeBuildSubsets>
   </PropertyGroup>
 
-  <PropertyGroup Condition="$(_subset.Contains('+clr.nativeaotlibs+')) and '$(NativeAotSupported)' == 'true'">
+  <PropertyGroup Condition="$(_subset.Contains('+clr.nativeaotruntime+')) and '$(NativeAotSupported)' == 'true'">
     <ClrRuntimeBuildSubsets>$(ClrRuntimeBuildSubsets);ClrNativeAotSubset=true</ClrRuntimeBuildSubsets>
   </PropertyGroup>
 
diff --git a/eng/pipelines/coreclr/templates/build-job.yml b/eng/pipelines/coreclr/templates/build-job.yml
index 713882250e627a..9048e8ed4fe8a2 100644
--- a/eng/pipelines/coreclr/templates/build-job.yml
+++ b/eng/pipelines/coreclr/templates/build-job.yml
@@ -212,7 +212,7 @@ jobs:
 
     # Build CoreCLR Managed Components
     - ${{ if or(ne(parameters.osGroup, 'Linux'), ne(parameters.archType, 'x86')) }}:
-      - script: $(Build.SourcesDirectory)$(dir)build$(scriptExt) -subset clr.corelib+clr.nativecorelib+clr.tools+clr.packages+clr.paltestlist $(crossArg) -arch $(archType) $(osArg) -c $(buildConfig) $(pgoInstrumentArg) $(officialBuildIdArg) -ci
+      - script: $(Build.SourcesDirectory)$(dir)build$(scriptExt) -subset clr.corelib+clr.nativecorelib+clr.nativeaotlibs+clr.tools+clr.packages+clr.paltestlist $(crossArg) -arch $(archType) $(osArg) -c $(buildConfig) $(pgoInstrumentArg) $(officialBuildIdArg) -ci
         displayName: Build managed product components and packages
     - ${{ if and(eq(parameters.osGroup, 'Linux'), eq(parameters.archType, 'x86')) }}:
       - script: $(Build.SourcesDirectory)$(dir)build$(scriptExt) -subset clr.corelib $(crossArg) -arch $(archType) $(osArg) -c $(buildConfig) $(pgoInstrumentArg) $(officialBuildIdArg) -ci
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index 1c376cad61b93e..9d3bbfe477d8e0 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -211,7 +211,7 @@ jobs:
       testGroup: innerloop
       timeoutInMinutes: 120
       nameSuffix: NativeAOT
-      buildArgs: -s clr.jit+clr.tools+clr.nativeaotlibs+libs -rc $(_BuildConfig) -lc Release
+      buildArgs: -s clr.jit+clr.tools+clr.nativeaotlibs+clr.nativeaotruntime+libs -rc $(_BuildConfig) -lc Release
       extraStepsTemplate: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
       condition: >-
         or(
@@ -233,7 +233,7 @@ jobs:
       testGroup: innerloop
       timeoutInMinutes: 120
       nameSuffix: NativeAOT
-      buildArgs: -s clr.jit+clr.tools+clr.nativeaotlibs+libs -rc $(_BuildConfig) -lc Release
+      buildArgs: -s clr.jit+clr.tools+clr.nativeaotlibs+clr.nativeaotruntime+libs -rc $(_BuildConfig) -lc Release
       extraStepsTemplate: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
       condition: >-
         or(
@@ -257,7 +257,7 @@ jobs:
       testGroup: innerloop
       timeoutInMinutes: 120
       nameSuffix: NativeAOT
-      buildArgs: -s clr.jit+clr.tools+clr.nativeaotlibs+libs -rc $(_BuildConfig) -lc Release
+      buildArgs: -s clr.jit+clr.tools+clr.nativeaotlibs+clr.nativeaotruntime+libs -rc $(_BuildConfig) -lc Release
       extraStepsTemplate: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
       condition: >-
         or(

From 9ac38cf9a6786405dc6c53d9def7213954c5ae2f Mon Sep 17 00:00:00 2001
From: Marek Safar <marek.safar@gmail.com>
Date: Fri, 28 Jan 2022 14:58:16 +0100
Subject: [PATCH 141/161] Remove empty Dispose method in InflaterManaged
 (#64443)

---
 .../DeflateManaged/DeflateManagedStream.cs           | 12 ++----------
 .../IO/Compression/DeflateManaged/InflaterManaged.cs |  2 --
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/DeflateManagedStream.cs b/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/DeflateManagedStream.cs
index ec71718a511d3d..ca31e978b332f0 100644
--- a/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/DeflateManagedStream.cs
+++ b/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/DeflateManagedStream.cs
@@ -310,16 +310,8 @@ protected override void Dispose(bool disposing)
                 finally
                 {
                     _stream = null!;
-
-                    try
-                    {
-                        _inflater?.Dispose();
-                    }
-                    finally
-                    {
-                        _inflater = null!;
-                        base.Dispose(disposing);
-                    }
+                    _inflater = null!;
+                    base.Dispose(disposing);
                 }
             }
         }
diff --git a/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/InflaterManaged.cs b/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/InflaterManaged.cs
index a127d93bd1d44b..7222011895309e 100644
--- a/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/InflaterManaged.cs
+++ b/src/libraries/System.IO.Compression/src/System/IO/Compression/DeflateManaged/InflaterManaged.cs
@@ -689,7 +689,5 @@ private bool DecodeDynamicBlockHeader()
             _state = InflaterState.DecodeTop;
             return true;
         }
-
-        public void Dispose() { }
     }
 }

From 82c45caafbbbb252a9fe4e231f84b3a42ad0c3c2 Mon Sep 17 00:00:00 2001
From: Maxim Lipnin <v-maxlip@microsoft.com>
Date: Fri, 28 Jan 2022 17:22:30 +0300
Subject: [PATCH 142/161] [mono][windows] Disable
 Microsoft.Extensions.Logging.Generators.TestsLoggerMessageGeneratorEmitterTests
 with ActiveIssue (#64436)

Addresses #64344 (comment)

... and skips System.Reflection.Emit.Tests.ModuleBuilderDefineInitializedData.DefineInitializedData_EnsureAlignmentIsMinimumNeededForUseOfCreateSpan test which requires reflection emit and fails on tvOS arm64 leg.
---
 .../LoggerMessageGeneratorEmitterTests.cs                       | 1 +
 .../tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
index 3b7079e9b83986..8ebb2ab8c0aa21 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/tests/Microsoft.Extensions.Logging.Generators.Tests/LoggerMessageGeneratorEmitterTests.cs
@@ -11,6 +11,7 @@
 namespace Microsoft.Extensions.Logging.Generators.Tests
 {
     [ActiveIssue("https://github.com/dotnet/runtime/issues/52062", TestPlatforms.Browser)]
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/34582", typeof(PlatformDetection), nameof(PlatformDetection.IsWindows), nameof(PlatformDetection.IsMonoRuntime))]
     public class LoggerMessageGeneratorEmitterTests
     {
         [Fact]
diff --git a/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs b/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs
index 9ad34ef353bc9b..178667241fdd6b 100644
--- a/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs
+++ b/src/libraries/System.Reflection.Emit/tests/ModuleBuilder/ModuleBuilderDefineInitializedData.cs
@@ -61,7 +61,7 @@ public void DefineInitializedData_CreateGlobalFunctionsCalled_ThrowsInvalidOpera
             Assert.Throws<InvalidOperationException>(() => module.DefineInitializedData("MyField2", new byte[] { 1, 0, 1 }, FieldAttributes.Public));
         }
 
-        [Fact]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsReflectionEmitSupported))]
         public void DefineInitializedData_EnsureAlignmentIsMinimumNeededForUseOfCreateSpan()
         {
             ModuleBuilder module = Helpers.DynamicModule();

From 8766a1cf1ed6c3b69cef50154139699b72fb52c5 Mon Sep 17 00:00:00 2001
From: Meri Khamoyan <96171496+mkhamoyan@users.noreply.github.com>
Date: Fri, 28 Jan 2022 19:02:34 +0400
Subject: [PATCH 143/161] #51371 removed CaseInsensitivePlatforms and
 CaseSensitivePlatforms parameters (#64440)

---
 .../System.IO.FileSystem/tests/Directory/Exists.cs          | 6 ++----
 .../tests/Directory/GetFileSystemEntries_str_str.cs         | 3 +--
 .../System.IO.FileSystem/tests/DirectoryInfo/Exists.cs      | 6 ++----
 src/libraries/System.IO.FileSystem/tests/File/Create.cs     | 3 +--
 src/libraries/System.IO.FileSystem/tests/File/Exists.cs     | 6 ++----
 src/libraries/System.IO.FileSystem/tests/FileInfo/Exists.cs | 6 ++----
 src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs  | 3 ---
 7 files changed, 10 insertions(+), 23 deletions(-)

diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs b/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs
index 9e3e21978eb138..983acfc5489369 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/Exists.cs
@@ -224,8 +224,7 @@ public void WindowsWhiteSpaceAsPath_ReturnsFalse(string component)
 
         }
 
-        [Fact]
-        [PlatformSpecific(CaseInsensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseInsensitiveOS))]
         public void DoesCaseInsensitiveInvariantComparisons()
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
@@ -234,8 +233,7 @@ public void DoesCaseInsensitiveInvariantComparisons()
             Assert.True(Exists(testDir.FullName.ToLowerInvariant()));
         }
 
-        [Fact]
-        [PlatformSpecific(CaseSensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseSensitiveOS))]
         public void DoesCaseSensitiveComparisons()
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
diff --git a/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs b/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs
index e439db9369f42d..97d8ec20b07ed1 100644
--- a/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs
+++ b/src/libraries/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str_str.cs
@@ -718,8 +718,7 @@ public void SearchPatternCaseSensitive()
             }
         }
 
-        [Fact]
-        [PlatformSpecific(CaseInsensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseInsensitiveOS))]
         public void SearchPatternCaseInsensitive()
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
diff --git a/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/Exists.cs b/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/Exists.cs
index 8a007e8df90248..9c076d4ddaeadd 100644
--- a/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/Exists.cs
+++ b/src/libraries/System.IO.FileSystem/tests/DirectoryInfo/Exists.cs
@@ -67,16 +67,14 @@ public void MissingDirectory(char trailingChar)
             Assert.False(info.Exists);
         }
 
-        [Fact]
-        [PlatformSpecific(CaseInsensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseInsensitiveOS))]
         public void CaseInsensitivity()
         {
             Assert.True(new DirectoryInfo(TestDirectory.ToUpperInvariant()).Exists);
             Assert.True(new DirectoryInfo(TestDirectory.ToLowerInvariant()).Exists);
         }
 
-        [Fact]
-        [PlatformSpecific(CaseSensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseSensitiveOS))]
         public void CaseSensitivity()
         {
             Assert.False(new DirectoryInfo(TestDirectory.ToUpperInvariant()).Exists);
diff --git a/src/libraries/System.IO.FileSystem/tests/File/Create.cs b/src/libraries/System.IO.FileSystem/tests/File/Create.cs
index 69e9042ae1b548..3b1b662a9873b8 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/Create.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/Create.cs
@@ -233,8 +233,7 @@ public void CaseSensitive()
             Assert.Throws<DirectoryNotFoundException>(() => File.Create(testFile.ToLowerInvariant()));
         }
 
-        [Fact]
-        [PlatformSpecific(CaseInsensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseInsensitiveOS))]
         public void CaseInsensitive()
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
diff --git a/src/libraries/System.IO.FileSystem/tests/File/Exists.cs b/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
index 9828ea7524a0e4..1fde8ae98ec7db 100644
--- a/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
+++ b/src/libraries/System.IO.FileSystem/tests/File/Exists.cs
@@ -166,8 +166,7 @@ public void WindowsNonSignificantWhiteSpaceAsPath_ReturnsFalse(string component)
 
         }
 
-        [Fact]
-        [PlatformSpecific(CaseInsensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseInsensitiveOS))]
         public void DoesCaseInsensitiveInvariantComparions()
         {
             FileInfo testFile = new FileInfo(GetTestFilePath());
@@ -177,8 +176,7 @@ public void DoesCaseInsensitiveInvariantComparions()
             Assert.True(Exists(testFile.FullName.ToLowerInvariant()));
         }
 
-        [Fact]
-        [PlatformSpecific(CaseSensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseSensitiveOS))]
         public void DoesCaseSensitiveComparisons()
         {
             FileInfo testFile = new FileInfo(GetTestFilePath());
diff --git a/src/libraries/System.IO.FileSystem/tests/FileInfo/Exists.cs b/src/libraries/System.IO.FileSystem/tests/FileInfo/Exists.cs
index be6f5e90fdf0d2..4435b64befbccb 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileInfo/Exists.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileInfo/Exists.cs
@@ -51,8 +51,7 @@ public void MissingDirectory(char trailingChar)
             Assert.False(info.Exists);
         }
 
-        [Fact]
-        [PlatformSpecific(CaseInsensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseInsensitiveOS))]
         public void CaseInsensitivity()
         {
             string path = GetTestFilePath();
@@ -61,8 +60,7 @@ public void CaseInsensitivity()
             Assert.True(new FileInfo(path.ToLowerInvariant()).Exists);
         }
 
-        [Fact]
-        [PlatformSpecific(CaseSensitivePlatforms)]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCaseSensitiveOS))]
         public void CaseSensitivity()
         {
             string path = GetTestFilePath();
diff --git a/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs b/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs
index 53251552104f68..3d309194df649b 100644
--- a/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs
+++ b/src/libraries/System.IO.FileSystem/tests/FileSystemTest.cs
@@ -11,9 +11,6 @@ public abstract partial class FileSystemTest : FileCleanupTestBase
     {
         public static readonly byte[] TestBuffer = { 0xBA, 0x5E, 0xBA, 0x11, 0xF0, 0x07, 0xBA, 0x11 };
 
-        protected const TestPlatforms CaseInsensitivePlatforms = TestPlatforms.Windows | TestPlatforms.OSX | TestPlatforms.MacCatalyst;
-        protected const TestPlatforms CaseSensitivePlatforms = TestPlatforms.AnyUnix & ~TestPlatforms.OSX & ~TestPlatforms.MacCatalyst;
-
         public static bool AreAllLongPathsAvailable => PathFeatures.AreAllLongPathsAvailable();
 
         public static bool LongPathsAreNotBlocked => !PathFeatures.AreLongPathsBlocked();

From 10926176d26c5e874886df8d9a776f7aa19ba548 Mon Sep 17 00:00:00 2001
From: Thays Grazia <thaystg@gmail.com>
Date: Fri, 28 Jan 2022 12:18:09 -0300
Subject: [PATCH 144/161] [wasm][debugger] Move the breakpoint line after
 applying changes (#64359)

When hot-reloading code with new lines added, VS automatically updates the breakpoints by sending Remove/SetBreakpoint commands.

Add a test case for the reload, with simulated VS part.
---
 .../DebuggerTestSuite/BreakpointTests.cs      | 26 +++++++++++++++++++
 .../DebuggerTestSuite/DebuggerTestBase.cs     |  6 ++++-
 .../MethodBody1.cs                            | 13 +++++++++-
 .../MethodBody1_v1.cs                         |  9 ++++++-
 .../MethodBody1_v2.cs                         | 14 +++++++++-
 5 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs
index f5e6a5b9c2b93e..30c9417b6e484f 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs
@@ -1124,5 +1124,31 @@ await EvaluateAndCheck(
                 }
             );
         }
+
+        [Fact]
+        public async Task DebugHotReloadMethod_CheckBreakpointLineUpdated_ByVS_Simulated()
+        {
+            string asm_file = Path.Combine(DebuggerTestAppPath, "ApplyUpdateReferencedAssembly.dll");
+            string pdb_file = Path.Combine(DebuggerTestAppPath, "ApplyUpdateReferencedAssembly.pdb");
+            string asm_file_hot_reload = Path.Combine(DebuggerTestAppPath, "../wasm/ApplyUpdateReferencedAssembly.dll");
+
+            var bp = await SetBreakpoint(".*/MethodBody1.cs$", 48, 12, use_regex: true);
+            var pause_location = await LoadAssemblyAndTestHotReloadUsingSDBWithoutChanges(
+                    asm_file, pdb_file, "MethodBody5", "StaticMethod1");
+
+            //apply first update
+            pause_location = await LoadAssemblyAndTestHotReloadUsingSDB(
+                    asm_file_hot_reload, "MethodBody5", "StaticMethod1", 1, 
+                    rebindBreakpoint : async () =>
+                    {
+                        await RemoveBreakpoint(bp.Value["breakpointId"].Value<string>());
+                        await SetBreakpoint(".*/MethodBody1.cs$", 49, 12, use_regex: true);
+                    });
+
+            JToken top_frame = pause_location["callFrames"]?[0];
+            AssertEqual("StaticMethod1", top_frame?["functionName"]?.Value<string>(), top_frame?.ToString());
+            CheckLocation("dotnet://ApplyUpdateReferencedAssembly.dll/MethodBody1.cs", 49, 12, scripts, top_frame["location"]);
+
+        }
     }
 }
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
index cf4eade5a81936..23ac172cf69b17 100644
--- a/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
+++ b/src/mono/wasm/debugger/DebuggerTestSuite/DebuggerTestBase.cs
@@ -1215,7 +1215,7 @@ internal async Task<JObject> LoadAssemblyAndTestHotReloadUsingSDBWithoutChanges(
             return await insp.WaitFor(Inspector.PAUSE);
         }
 
-        internal async Task<JObject> LoadAssemblyAndTestHotReloadUsingSDB(string asm_file_hot_reload, string class_name, string method_name, int id)
+        internal async Task<JObject> LoadAssemblyAndTestHotReloadUsingSDB(string asm_file_hot_reload, string class_name, string method_name, int id, Func<Task> rebindBreakpoint = null)
         {
             await cli.SendCommand("Debugger.resume", null, token);
             var bytes = File.ReadAllBytes($"{asm_file_hot_reload}.{id}.dmeta");
@@ -1245,6 +1245,10 @@ internal async Task<JObject> LoadAssemblyAndTestHotReloadUsingSDB(string asm_fil
                 dpdb = dpdb1
             });
             await cli.SendCommand("DotnetDebugger.applyUpdates", applyUpdates, token);
+
+            if (rebindBreakpoint != null)
+                await rebindBreakpoint();
+
             run_method = JObject.FromObject(new
             {
                 expression = "window.setTimeout(function() { invoke_static_method('[debugger-test] TestHotReloadUsingSDB:RunMethod', '" + class_name + "', '" + method_name + "'); }, 1);"
diff --git a/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1.cs b/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1.cs
index d092ec07cf7e5d..047e293c082363 100644
--- a/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1.cs
+++ b/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1.cs
@@ -3,7 +3,7 @@
 
 using System.Diagnostics;
 using System;
-
+//keep the same line number for class in the original file and the updates ones
 namespace ApplyUpdateReferencedAssembly
 {
     public class MethodBody1 {
@@ -38,4 +38,15 @@ public class MethodBody4 {
         public static void StaticMethod4 () {
         }
     }
+
+
+
+
+
+
+    public class MethodBody5 {
+        public static void StaticMethod1 () {
+            Console.WriteLine("original");
+        }
+    }
 }
diff --git a/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v1.cs b/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v1.cs
index 6ce229dff59668..ce9d974b8bf160 100644
--- a/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v1.cs
+++ b/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v1.cs
@@ -3,7 +3,7 @@
 
 using System.Diagnostics;
 using System;
-
+//keep the same line number for class in the original file and the updates ones
 namespace ApplyUpdateReferencedAssembly
 {
     public class MethodBody1 {
@@ -43,4 +43,11 @@ public static void StaticMethod4 () {
             Console.WriteLine(a + b);
         }
     }
+
+    public class MethodBody5 {
+        public static void StaticMethod1 () {
+            Console.WriteLine("beforeoriginal");
+            Console.WriteLine("original");
+        }
+    }
 }
diff --git a/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v2.cs b/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v2.cs
index 1ced5fd3826e1f..8850f85956d303 100644
--- a/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v2.cs
+++ b/src/mono/wasm/debugger/tests/ApplyUpdateReferencedAssembly/MethodBody1_v2.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 using System.Diagnostics;
 using System;
-
+//keep the same line number for class in the original file and the updates ones
 namespace ApplyUpdateReferencedAssembly
 {
     public class MethodBody1 {
@@ -38,4 +38,16 @@ public class MethodBody4 {
         public static void StaticMethod4 () {
         }
     }
+
+
+
+
+
+
+    public class MethodBody5 {
+        public static void StaticMethod1 () {
+            Console.WriteLine("beforeoriginal");
+            Console.WriteLine("original");
+        }
+    }
 }

From fd84f80df64fb686ce54918372ad2c19fb11c730 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Fri, 28 Jan 2022 17:17:17 +0100
Subject: [PATCH 145/161] pass the argument forward (#64445)

---
 .../src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs
index 348c7762ec9015..8a601345ee00a2 100644
--- a/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs
@@ -186,7 +186,7 @@ internal static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess a
         {
             long fileLength;
             Interop.Sys.Permissions filePermissions;
-            return Open(fullPath, mode, access, share, options, preallocationSize, openPermissions, out fileLength, out filePermissions, null);
+            return Open(fullPath, mode, access, share, options, preallocationSize, openPermissions, out fileLength, out filePermissions, createOpenException);
         }
 
         private static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize,

From ddbbc70ddcd0c74c2fe882b50df0eda5e563a5e8 Mon Sep 17 00:00:00 2001
From: Kevin Jones <kevin@vcsjones.com>
Date: Fri, 28 Jan 2022 11:24:27 -0500
Subject: [PATCH 146/161] Ignore non-X509 certificates in SignedCms

This allows for AttributeCertificateV1/AttributeCertificateV2/OtherCertificate
entries in the SignedCms without causing a decode error.  That data is not presented
to callers via the SignedCms object, but the behavior is consistent with SignedCms on
.NET Framework and its underlying WinCryptMsg counterpart.

Co-authored-by: Jeremy Barton <jbarton@microsoft.com>
---
 .../System.Security.Cryptography.Pkcs.csproj  |   4 +
 .../Pkcs/Asn1/CertificateChoiceAsn.xml        |  10 +-
 .../Pkcs/Asn1/CertificateChoiceAsn.xml.cs     | 114 +++++++++++++
 .../Pkcs/Asn1/OtherCertificateFormat.xml      |  17 ++
 .../Pkcs/Asn1/OtherCertificateFormat.xml.cs   |  98 +++++++++++
 .../Security/Cryptography/Pkcs/SignedCms.cs   |  12 +-
 .../tests/SignedCms/SignedCmsTests.cs         |   9 +
 .../tests/SignedCms/SignedDocuments.cs        | 154 ++++++++++++++++++
 8 files changed, 410 insertions(+), 8 deletions(-)
 create mode 100644 src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml
 create mode 100644 src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml.cs

diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj b/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj
index 9ccb53cebf2077..c0c2da22f98513 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj
+++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj
@@ -490,6 +490,10 @@ System.Security.Cryptography.Pkcs.EnvelopedCms</PackageDescription>
     <Compile Include="System\Security\Cryptography\Pkcs\Asn1\MessageImprint.xml.cs">
       <DependentUpon>System\Security\Cryptography\Pkcs\Asn1\MessageImprint.xml</DependentUpon>
     </Compile>
+    <AsnXml Include="System\Security\Cryptography\Pkcs\Asn1\OtherCertificateFormat.xml" />
+    <Compile Include="System\Security\Cryptography\Pkcs\Asn1\OtherCertificateFormat.xml.cs">
+      <DependentUpon>System\Security\Cryptography\Pkcs\Asn1\OtherCertificateFormat.xml</DependentUpon>
+    </Compile>
     <Compile Include="System\Security\Cryptography\Pkcs\Asn1\PkiFailureInfo.cs" />
     <Compile Include="System\Security\Cryptography\Pkcs\Asn1\PkiStatus.cs" />
     <AsnXml Include="System\Security\Cryptography\Pkcs\Asn1\PkiStatusInfo.xml" />
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml
index d9b497ab9d0009..9bc76b343264dc 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml
+++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml
@@ -15,12 +15,10 @@
         other[3] IMPLICIT OtherCertificateFormat
     }
 
-    OtherCertificateFormat ::= SEQUENCE {
-        otherCertFormat OBJECT IDENTIFIER,
-        otherCert ANY DEFINED BY otherCertFormat
-    }
-
-    Except we only support public key certificates, so just trim the choice here.
   -->
   <asn:AnyValue name="Certificate" universalTagNumber="16" />
+  <asn:AnyValue name="ExtendedCertificate" implicitTag="0" />
+  <asn:AnyValue name="AttributeCertificateV1" implicitTag="1" />
+  <asn:AnyValue name="AttributeCertificateV2" implicitTag="2" />
+  <asn:AsnType name="OtherCertificateFormat" typeName="System.Security.Cryptography.Pkcs.Asn1.OtherCertificateFormat" implicitTag="3" />
 </asn:Choice>
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml.cs b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml.cs
index c9107fa3d9c286..0b602a0aa55d59 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml.cs
+++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/CertificateChoiceAsn.xml.cs
@@ -12,6 +12,10 @@ namespace System.Security.Cryptography.Pkcs.Asn1
     internal partial struct CertificateChoiceAsn
     {
         internal ReadOnlyMemory<byte>? Certificate;
+        internal ReadOnlyMemory<byte>? ExtendedCertificate;
+        internal ReadOnlyMemory<byte>? AttributeCertificateV1;
+        internal ReadOnlyMemory<byte>? AttributeCertificateV2;
+        internal System.Security.Cryptography.Pkcs.Asn1.OtherCertificateFormat? OtherCertificateFormat;
 
 #if DEBUG
         static CertificateChoiceAsn()
@@ -28,6 +32,10 @@ static CertificateChoiceAsn()
             };
 
             ensureUniqueTag(new Asn1Tag((UniversalTagNumber)16), "Certificate");
+            ensureUniqueTag(new Asn1Tag(TagClass.ContextSpecific, 0), "ExtendedCertificate");
+            ensureUniqueTag(new Asn1Tag(TagClass.ContextSpecific, 1), "AttributeCertificateV1");
+            ensureUniqueTag(new Asn1Tag(TagClass.ContextSpecific, 2), "AttributeCertificateV2");
+            ensureUniqueTag(new Asn1Tag(TagClass.ContextSpecific, 3), "OtherCertificateFormat");
         }
 #endif
 
@@ -60,6 +68,90 @@ internal void Encode(AsnWriter writer)
                 wroteValue = true;
             }
 
+            if (ExtendedCertificate.HasValue)
+            {
+                if (wroteValue)
+                    throw new CryptographicException();
+
+                // Validator for tag constraint for ExtendedCertificate
+                {
+                    if (!Asn1Tag.TryDecode(ExtendedCertificate.Value.Span, out Asn1Tag validateTag, out _) ||
+                        !validateTag.HasSameClassAndValue(new Asn1Tag(TagClass.ContextSpecific, 0)))
+                    {
+                        throw new CryptographicException();
+                    }
+                }
+
+                try
+                {
+                    writer.WriteEncodedValue(ExtendedCertificate.Value.Span);
+                }
+                catch (ArgumentException e)
+                {
+                    throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e);
+                }
+                wroteValue = true;
+            }
+
+            if (AttributeCertificateV1.HasValue)
+            {
+                if (wroteValue)
+                    throw new CryptographicException();
+
+                // Validator for tag constraint for AttributeCertificateV1
+                {
+                    if (!Asn1Tag.TryDecode(AttributeCertificateV1.Value.Span, out Asn1Tag validateTag, out _) ||
+                        !validateTag.HasSameClassAndValue(new Asn1Tag(TagClass.ContextSpecific, 1)))
+                    {
+                        throw new CryptographicException();
+                    }
+                }
+
+                try
+                {
+                    writer.WriteEncodedValue(AttributeCertificateV1.Value.Span);
+                }
+                catch (ArgumentException e)
+                {
+                    throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e);
+                }
+                wroteValue = true;
+            }
+
+            if (AttributeCertificateV2.HasValue)
+            {
+                if (wroteValue)
+                    throw new CryptographicException();
+
+                // Validator for tag constraint for AttributeCertificateV2
+                {
+                    if (!Asn1Tag.TryDecode(AttributeCertificateV2.Value.Span, out Asn1Tag validateTag, out _) ||
+                        !validateTag.HasSameClassAndValue(new Asn1Tag(TagClass.ContextSpecific, 2)))
+                    {
+                        throw new CryptographicException();
+                    }
+                }
+
+                try
+                {
+                    writer.WriteEncodedValue(AttributeCertificateV2.Value.Span);
+                }
+                catch (ArgumentException e)
+                {
+                    throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e);
+                }
+                wroteValue = true;
+            }
+
+            if (OtherCertificateFormat.HasValue)
+            {
+                if (wroteValue)
+                    throw new CryptographicException();
+
+                OtherCertificateFormat.Value.Encode(writer, new Asn1Tag(TagClass.ContextSpecific, 3));
+                wroteValue = true;
+            }
+
             if (!wroteValue)
             {
                 throw new CryptographicException();
@@ -107,6 +199,28 @@ private static void DecodeCore(ref AsnValueReader reader, ReadOnlyMemory<byte> r
                 tmpSpan = reader.ReadEncodedValue();
                 decoded.Certificate = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();
             }
+            else if (tag.HasSameClassAndValue(new Asn1Tag(TagClass.ContextSpecific, 0)))
+            {
+                tmpSpan = reader.ReadEncodedValue();
+                decoded.ExtendedCertificate = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();
+            }
+            else if (tag.HasSameClassAndValue(new Asn1Tag(TagClass.ContextSpecific, 1)))
+            {
+                tmpSpan = reader.ReadEncodedValue();
+                decoded.AttributeCertificateV1 = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();
+            }
+            else if (tag.HasSameClassAndValue(new Asn1Tag(TagClass.ContextSpecific, 2)))
+            {
+                tmpSpan = reader.ReadEncodedValue();
+                decoded.AttributeCertificateV2 = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();
+            }
+            else if (tag.HasSameClassAndValue(new Asn1Tag(TagClass.ContextSpecific, 3)))
+            {
+                System.Security.Cryptography.Pkcs.Asn1.OtherCertificateFormat tmpOtherCertificateFormat;
+                System.Security.Cryptography.Pkcs.Asn1.OtherCertificateFormat.Decode(ref reader, new Asn1Tag(TagClass.ContextSpecific, 3), rebind, out tmpOtherCertificateFormat);
+                decoded.OtherCertificateFormat = tmpOtherCertificateFormat;
+
+            }
             else
             {
                 throw new CryptographicException();
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml
new file mode 100644
index 00000000000000..704a42f6d64b85
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<asn:Sequence
+  xmlns:asn="http://schemas.dot.net/asnxml/201808/"
+  name="OtherCertificateFormat"
+  namespace="System.Security.Cryptography.Pkcs.Asn1">
+
+  <!--
+    https://tools.ietf.org/html/rfc5652#section-10.2.2
+
+    OtherCertificateFormat ::= SEQUENCE {
+        otherCertFormat OBJECT IDENTIFIER,
+        otherCert ANY DEFINED BY otherCertFormat
+    }
+  -->
+  <asn:ObjectIdentifier name="OtherCertFormat" backingType="string" />
+  <asn:AnyValue name="OtherCert" />
+</asn:Sequence>
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml.cs b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml.cs
new file mode 100644
index 00000000000000..aeb18133756af6
--- /dev/null
+++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/Asn1/OtherCertificateFormat.xml.cs
@@ -0,0 +1,98 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1028 // ignore whitespace warnings for generated code
+using System;
+using System.Formats.Asn1;
+using System.Runtime.InteropServices;
+
+namespace System.Security.Cryptography.Pkcs.Asn1
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal partial struct OtherCertificateFormat
+    {
+        internal string OtherCertFormat;
+        internal ReadOnlyMemory<byte> OtherCert;
+
+        internal void Encode(AsnWriter writer)
+        {
+            Encode(writer, Asn1Tag.Sequence);
+        }
+
+        internal void Encode(AsnWriter writer, Asn1Tag tag)
+        {
+            writer.PushSequence(tag);
+
+            try
+            {
+                writer.WriteObjectIdentifier(OtherCertFormat);
+            }
+            catch (ArgumentException e)
+            {
+                throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e);
+            }
+            try
+            {
+                writer.WriteEncodedValue(OtherCert.Span);
+            }
+            catch (ArgumentException e)
+            {
+                throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e);
+            }
+            writer.PopSequence(tag);
+        }
+
+        internal static OtherCertificateFormat Decode(ReadOnlyMemory<byte> encoded, AsnEncodingRules ruleSet)
+        {
+            return Decode(Asn1Tag.Sequence, encoded, ruleSet);
+        }
+
+        internal static OtherCertificateFormat Decode(Asn1Tag expectedTag, ReadOnlyMemory<byte> encoded, AsnEncodingRules ruleSet)
+        {
+            try
+            {
+                AsnValueReader reader = new AsnValueReader(encoded.Span, ruleSet);
+
+                DecodeCore(ref reader, expectedTag, encoded, out OtherCertificateFormat decoded);
+                reader.ThrowIfNotEmpty();
+                return decoded;
+            }
+            catch (AsnContentException e)
+            {
+                throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e);
+            }
+        }
+
+        internal static void Decode(ref AsnValueReader reader, ReadOnlyMemory<byte> rebind, out OtherCertificateFormat decoded)
+        {
+            Decode(ref reader, Asn1Tag.Sequence, rebind, out decoded);
+        }
+
+        internal static void Decode(ref AsnValueReader reader, Asn1Tag expectedTag, ReadOnlyMemory<byte> rebind, out OtherCertificateFormat decoded)
+        {
+            try
+            {
+                DecodeCore(ref reader, expectedTag, rebind, out decoded);
+            }
+            catch (AsnContentException e)
+            {
+                throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e);
+            }
+        }
+
+        private static void DecodeCore(ref AsnValueReader reader, Asn1Tag expectedTag, ReadOnlyMemory<byte> rebind, out OtherCertificateFormat decoded)
+        {
+            decoded = default;
+            AsnValueReader sequenceReader = reader.ReadSequence(expectedTag);
+            ReadOnlySpan<byte> rebindSpan = rebind.Span;
+            int offset;
+            ReadOnlySpan<byte> tmpSpan;
+
+            decoded.OtherCertFormat = sequenceReader.ReadObjectIdentifier();
+            tmpSpan = sequenceReader.ReadEncodedValue();
+            decoded.OtherCert = rebindSpan.Overlaps(tmpSpan, out offset) ? rebind.Slice(offset, tmpSpan.Length) : tmpSpan.ToArray();
+
+            sequenceReader.ThrowIfNotEmpty();
+        }
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignedCms.cs b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignedCms.cs
index 188ca0039a3c96..bc38187f6edc23 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignedCms.cs
+++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignedCms.cs
@@ -89,8 +89,16 @@ public X509Certificate2Collection Certificates
 
                 foreach (CertificateChoiceAsn choice in certChoices)
                 {
-                    Debug.Assert(choice.Certificate.HasValue);
-                    coll.Add(new X509Certificate2(choice.Certificate.Value.ToArray()));
+                    if (choice.Certificate.HasValue)
+                    {
+                        coll.Add(new X509Certificate2(choice.Certificate.Value
+#if NET5_0_OR_GREATER
+                            .Span
+#else
+                            .ToArray()
+#endif
+                            ));
+                    }
                 }
 
                 return coll;
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedCmsTests.cs b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedCmsTests.cs
index c53e966a72d9e5..c89cfa54bb8c27 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedCmsTests.cs
+++ b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedCmsTests.cs
@@ -1602,6 +1602,15 @@ public static void CheckNoSignature_FromCoreFx_TamperIssuerName()
             signers[0].CheckHash();
         }
 
+        [Fact]
+        public static void Decode_CanDecodeWithAttributeCertificate()
+        {
+            SignedCms cms = new SignedCms();
+            cms.Decode(SignedDocuments.TstWithAttributeCertificate);
+            Assert.Equal(2, cms.Certificates.Count);
+            cms.CheckSignature(verifySignatureOnly: true);
+        }
+
         private static void CheckNoSignature(byte[] encoded, bool badOid=false)
         {
             SignedCms cms = new SignedCms();
diff --git a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedDocuments.cs b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedDocuments.cs
index 55d42f6b02ee88..cce3114824794e 100644
--- a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedDocuments.cs
+++ b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignedDocuments.cs
@@ -1472,5 +1472,159 @@ internal static class SignedDocuments
             "2B78166BDB1612848B535ADC3F0E7BE52991A17F48AFDCCC1698A236BA338930" +
             "50EBAAC4460DAA35185C16670F597E0E6E0CB0AA83F51AAEF452F3367DD9350A" +
             "8A49A5A8F79DF8E921303AB5D6646A482F0F59D9980310E1AE3EE8D77CB857").HexToByteArray();
+
+        internal static readonly byte[] TstWithAttributeCertificate = (
+            "308212E306092A864886F70D010702A08212D4308212D0020103310F300D0609" +
+            "608648016503040201050030820159060B2A864886F70D0109100104A0820148" +
+            "0482014430820140020101060A2B0601040184590A03013031300D0609608648" +
+            "01650304020105000420C61245B435391DCDD1EFF021681FA2A46E69410A9E23" +
+            "09F1B1736BB7C2BB504402066148B8B838B11813323032313130303730343230" +
+            "30372E3037345A3004800201F4A081D8A481D53081D2310B3009060355040613" +
+            "025553311330110603550408130A57617368696E67746F6E3110300E06035504" +
+            "0713075265646D6F6E64311E301C060355040A13154D6963726F736F66742043" +
+            "6F72706F726174696F6E312D302B060355040B13244D6963726F736F66742049" +
+            "72656C616E64204F7065726174696F6E73204C696D6974656431263024060355" +
+            "040B131D5468616C6573205453532045534E3A303834322D344245362D433239" +
+            "41312530230603550403131C4D6963726F736F66742054696D652D5374616D70" +
+            "2053657276696365A0820E4A308204F9308203E1A00302010202133300000139" +
+            "CCE8E8438BF034E1000000000139300D06092A864886F70D01010B0500307C31" +
+            "0B3009060355040613025553311330110603550408130A57617368696E67746F" +
+            "6E3110300E060355040713075265646D6F6E64311E301C060355040A13154D69" +
+            "63726F736F667420436F72706F726174696F6E312630240603550403131D4D69" +
+            "63726F736F66742054696D652D5374616D70205043412032303130301E170D32" +
+            "30313031353137323832315A170D3232303131323137323832315A3081D2310B" +
+            "3009060355040613025553311330110603550408130A57617368696E67746F6E" +
+            "3110300E060355040713075265646D6F6E64311E301C060355040A13154D6963" +
+            "726F736F667420436F72706F726174696F6E312D302B060355040B13244D6963" +
+            "726F736F6674204972656C616E64204F7065726174696F6E73204C696D697465" +
+            "6431263024060355040B131D5468616C6573205453532045534E3A303834322D" +
+            "344245362D43323941312530230603550403131C4D6963726F736F6674205469" +
+            "6D652D5374616D70205365727669636530820122300D06092A864886F70D0101" +
+            "0105000382010F003082010A0282010100DA13F98CE3259325A18EB32A06FCA2" +
+            "78F85A1F98374F7F50C1DBBA1EA02759C2E5CFDFD92A80BF405CF8E606F469DD" +
+            "7822FA856859B627AA3EBE185B7F8A1024E1C34DC8D95C12904DB413FF0E8B09" +
+            "6BDD0979C5425D9AF2711DE3612613BAF145598ABA66C7A04295F90C1874673B" +
+            "D2AE4EF0CD9892A27F4AD72B16116D9A117172F559FA08386B3CEF13CEFEB282" +
+            "33615EB3A8CD8A58EFD34B2F597A88B95F84286D5E802AEC091F4F32499DA540" +
+            "15F39DDF2BC03CF2EBE058A895E29BE6FE57EEC4DFBE356FA710F5F98E340A47" +
+            "2E1906AA8D3BFC1D783641AAA8EF7BF210235ED5684292A32AEEB2C57CECB294" +
+            "278F4AE57EC57F1F2496FE5FA2CF1ECA4F0203010001A382011B30820117301D" +
+            "0603551D0E04160414999E9B867254C299DA928AB19F46F6502D060CE9301F06" +
+            "03551D23041830168014D5633A5C8A3190F3437B7C461BC533685A856D553056" +
+            "0603551D1F044F304D304BA049A0478645687474703A2F2F63726C2E6D696372" +
+            "6F736F66742E636F6D2F706B692F63726C2F70726F64756374732F4D69635469" +
+            "6D5374615043415F323031302D30372D30312E63726C305A06082B0601050507" +
+            "0101044E304C304A06082B06010505073002863E687474703A2F2F7777772E6D" +
+            "6963726F736F66742E636F6D2F706B692F63657274732F4D696354696D537461" +
+            "5043415F323031302D30372D30312E637274300C0603551D130101FF04023000" +
+            "30130603551D25040C300A06082B06010505070308300D06092A864886F70D01" +
+            "010B05000382010100585C286AF3FF371A85CDC15AED438288BF100DB126FBBA" +
+            "F6118893A16D20F1D758C8AE566B514077FCA7243D6AC9CFD9C71F473FDD32A9" +
+            "7293FABCF8835C08B1049694A09BDD71B821586C584084B26DA28CDFDFC687E6" +
+            "B63667158DF5BB831249C97E21A22BA43EF2490235699B5A3D83C51C0417C21F" +
+            "0708C5EC43E160381D8A52B3E3CEAEC21828B28AF51AE0D68A56231A830DAB79" +
+            "6BC0322463FF37294A49868AE5A6205D908344B159027F3C842E67BD0B7B5A99" +
+            "9B4C497C6B519C17E96ADFDDD498100AB2DFA3C9649AE2C13C21BF38C87AA0FC" +
+            "78ACD4521DEE7C4DBF1231006DA6C1842A36FAD528CA74FA4C026D8DD8AF6B88" +
+            "3B3FBDFF550AD270C73082067130820459A003020102020A6109812A00000000" +
+            "0002300D06092A864886F70D01010B0500308188310B30090603550406130255" +
+            "53311330110603550408130A57617368696E67746F6E3110300E060355040713" +
+            "075265646D6F6E64311E301C060355040A13154D6963726F736F667420436F72" +
+            "706F726174696F6E31323030060355040313294D6963726F736F667420526F6F" +
+            "7420436572746966696361746520417574686F726974792032303130301E170D" +
+            "3130303730313231333635355A170D3235303730313231343635355A307C310B" +
+            "3009060355040613025553311330110603550408130A57617368696E67746F6E" +
+            "3110300E060355040713075265646D6F6E64311E301C060355040A13154D6963" +
+            "726F736F667420436F72706F726174696F6E312630240603550403131D4D6963" +
+            "726F736F66742054696D652D5374616D7020504341203230313030820122300D" +
+            "06092A864886F70D01010105000382010F003082010A0282010100A91D0DBC77" +
+            "118A3A20ECFC1397F5FA7F69946B745410D5A50A008285FBED7C684B2C5FC5C3" +
+            "E561C276B73E662B5BF015532704311F411B1A951DCE09138E7C613059B13044" +
+            "0FF160888454430CD74DB83808B342DD93ACD67330572682A3450DD0EAF54781" +
+            "CDBF246032586046F258478632841E746167915F8154B1CF934C92C1C4A65DD1" +
+            "61136E28C61AF98680BBDF61FC46C1271D246712721A218AAF4B64895062B15D" +
+            "FD771F3DF05775ACBD8A424D4051D10F9C063E677FF566C00396447EEFD04BFD" +
+            "6EE59ACAB1A8F27A2A0A31F0DA4E0691B6880835E8781CB0E999CD3CE72F44BA" +
+            "A7F4DC64BDA401C120099378CDFCBCC0C9445D5E169C01054F224D0203010001" +
+            "A38201E6308201E2301006092B06010401823715010403020100301D0603551D" +
+            "0E04160414D5633A5C8A3190F3437B7C461BC533685A856D55301906092B0601" +
+            "040182371402040C1E0A00530075006200430041300B0603551D0F0404030201" +
+            "86300F0603551D130101FF040530030101FF301F0603551D23041830168014D5" +
+            "F656CB8FE8A25C6268D13D94905BD7CE9A18C430560603551D1F044F304D304B" +
+            "A049A0478645687474703A2F2F63726C2E6D6963726F736F66742E636F6D2F70" +
+            "6B692F63726C2F70726F64756374732F4D6963526F6F4365724175745F323031" +
+            "302D30362D32332E63726C305A06082B06010505070101044E304C304A06082B" +
+            "06010505073002863E687474703A2F2F7777772E6D6963726F736F66742E636F" +
+            "6D2F706B692F63657274732F4D6963526F6F4365724175745F323031302D3036" +
+            "2D32332E6372743081A00603551D200101FF04819530819230818F06092B0601" +
+            "040182372E03308181303D06082B060105050702011631687474703A2F2F7777" +
+            "772E6D6963726F736F66742E636F6D2F504B492F646F63732F4350532F646566" +
+            "61756C742E68746D304006082B0601050507020230341E32201D004C00650067" +
+            "0061006C005F0050006F006C006900630079005F00530074006100740065006D" +
+            "0065006E0074002E201D300D06092A864886F70D01010B0500038202010007E6" +
+            "88510DE2C6E0983F8171033D9DA3A1216FB3EBA6CCF531BECF05E2A9FEFA576D" +
+            "1930B3C2C566C96ADFF5E7F078BDC7A89E25E3F9BCED6B5457082B51824412FB" +
+            "B9538CCCF460128A76CC4040419BDC5C17FF5CF95E17359824564B74EF4210C8" +
+            "AFBF7FC67FF2377D5A3F1CF299794A915200AF380F17F52F798165D9A9B56BE4" +
+            "C7CEF6CA7A006F4B304424223CCFED03A5968F5929BCB6FD04E1709F324A27FD" +
+            "55AF2FFEB6E58E33BB625F9ADB5740E9F1CE9966908CFF6A627FDDC54A0B9126" +
+            "E239EC194A71639D7B216DC39CA3A23CFA7F7D966A9078A66DD2E19CF91DFC38" +
+            "D894F4C6A50A9686A4BD9E1AAE044283B8B5809B223820B525E564ECF7F4BF7E" +
+            "6359250F7A2E395776A271AA068A0F8916BA61A711CB9AD80E479A80C5D0CDA7" +
+            "D0EF7D83F0E13B7109DF5D7498220861DAB0501E6FBDF1E100DFE73107A4933A" +
+            "F7654778E8F8A848ABF7DE727E616B6F77A981CBA709AC39BBECC6CBD882B472" +
+            "CD1DF4B885011E80FB1B892A5439B25BDAC80D55997A87733B08E6982DEA8DE0" +
+            "332E1229F5C02F542721F7C8AC4EDA28B8B1A9DB96B2A742A2C9CF19414DE086" +
+            "F92A9AA3116630D3BB74324BDF637BF5998A2F1BC721AF59B5AEDC443C975071" +
+            "D7A1D2C555E369DE57C1D1DE30C0FDCCE64DFB0DBF5D4FE99D1E19382FBCCF58" +
+            "052EEF0DA05035DAEF09271CD5B37E351E08BADA36DBD35F8FDE74884912A182" +
+            "02D43082023D02010130820100A181D8A481D53081D2310B3009060355040613" +
+            "025553311330110603550408130A57617368696E67746F6E3110300E06035504" +
+            "0713075265646D6F6E64311E301C060355040A13154D6963726F736F66742043" +
+            "6F72706F726174696F6E312D302B060355040B13244D6963726F736F66742049" +
+            "72656C616E64204F7065726174696F6E73204C696D6974656431263024060355" +
+            "040B131D5468616C6573205453532045534E3A303834322D344245362D433239" +
+            "41312530230603550403131C4D6963726F736F66742054696D652D5374616D70" +
+            "2053657276696365A2230A0101300706052B0E03021A0315000D4D94FE1BDE96" +
+            "848D743F1DEE4A04C6B3658C07A08183308180A47E307C310B30090603550406" +
+            "13025553311330110603550408130A57617368696E67746F6E3110300E060355" +
+            "040713075265646D6F6E64311E301C060355040A13154D6963726F736F667420" +
+            "436F72706F726174696F6E312630240603550403131D4D6963726F736F667420" +
+            "54696D652D5374616D70205043412032303130300D06092A864886F70D010105" +
+            "0500020500E5084E973022180F32303231313030373030333433315A180F3230" +
+            "3231313030383030333433315A3074303A060A2B0601040184590A0401312C30" +
+            "2A300A020500E5084E97020100300702010002021DE630070201000202113630" +
+            "0A020500E509A0170201003036060A2B0601040184590A040231283026300C06" +
+            "0A2B0601040184590A0302A00A3008020100020307A120A10A30080201000203" +
+            "0186A0300D06092A864886F70D0101050500038181002AE0DF2A01AAE13A86C0" +
+            "2DD8ECA787327C8F04A7C13D47256E65C60676B8372EE46362CD35391B6B898E" +
+            "DC1884082AAA7CF9B1CF40BE2C30146D0080ACB225C50B7C1FE94694732EDEEB" +
+            "9EDE73DB7D8C0762CBDFABD3ACCC82DD3858AA16C3ED185A40A39E9676772099" +
+            "346E3362621286651B06D9AD26D574F967F6C7EC335A3182030D308203090201" +
+            "01308193307C310B3009060355040613025553311330110603550408130A5761" +
+            "7368696E67746F6E3110300E060355040713075265646D6F6E64311E301C0603" +
+            "55040A13154D6963726F736F667420436F72706F726174696F6E312630240603" +
+            "550403131D4D6963726F736F66742054696D652D5374616D7020504341203230" +
+            "313002133300000139CCE8E8438BF034E1000000000139300D06096086480165" +
+            "030402010500A082014A301A06092A864886F70D010903310D060B2A864886F7" +
+            "0D0109100104302F06092A864886F70D01090431220420EA37C01965AB5A8B08" +
+            "C2A59F8EF2008C2B60F78E7F0385E2DD18A07C63433EF43081FA060B2A864886" +
+            "F70D010910022F3181EA3081E73081E43081BD04203CA18EE438A3D7247B3142" +
+            "B1E28105AE7C6A5527F39A7A9F26A6D4A0070FFC9F308198308180A47E307C31" +
+            "0B3009060355040613025553311330110603550408130A57617368696E67746F" +
+            "6E3110300E060355040713075265646D6F6E64311E301C060355040A13154D69" +
+            "63726F736F667420436F72706F726174696F6E312630240603550403131D4D69" +
+            "63726F736F66742054696D652D5374616D702050434120323031300213330000" +
+            "0139CCE8E8438BF034E1000000000139302204204A6E54AC16FAF6985726E0CB" +
+            "5480381C41888386AB1D1BECC241E6BCFCBDD45B300D06092A864886F70D0101" +
+            "0B0500048201006957F018A5C13CC539EB266EC2725998F4AC0ED50CE1CAA696" +
+            "CAE377977F45FB8030136A4038B49F7E5A6ADCF72FA3901C26B52815621F52A2" +
+            "EB2ACFC423087ECD954F34C341342E31BDF30443CAC4F1297AB0181467B90604" +
+            "DDCF11F9F8930290614E8AA9D868E56971E4F83427819F8A1A11ED87AD1D5469" +
+            "7AFFE60A8D7B7877CBB1D09F46397769B9D0F8EB605DBFE8F05C47A3F8BC1F65" +
+            "F9F63553F187194B35E971FEFFB00C9127BDFD0F7FCF2424BE2A108AC5C532EA" +
+            "6AB46C76047604BA7DF071EE0137B73F4D9DF616095C8F1CA9EB925B6D4C6ABC" +
+            "FFEB73A81903169C6B487B316AFC951F696831A4B29B9ABCEA7EBCD243A553D2" +
+            "F8B44FDA1B0AC0").HexToByteArray();
     }
 }

From 01fabd00268684e6443a34a348424dad7e1b7a90 Mon Sep 17 00:00:00 2001
From: Theodore Tsirpanis <teo@tsirpanis.gr>
Date: Fri, 28 Jan 2022 18:34:00 +0200
Subject: [PATCH 147/161] Use a non-generic TaskCompletionSource in
 SystemIPGlobalProperties. (#64423)

---
 .../System/Net/NetworkInformation/SystemIPGlobalProperties.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/SystemIPGlobalProperties.cs b/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/SystemIPGlobalProperties.cs
index ef5fb68547fc7f..2af54c4938ca4b 100644
--- a/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/SystemIPGlobalProperties.cs
+++ b/src/libraries/System.Net.NetworkInformation/src/System/Net/NetworkInformation/SystemIPGlobalProperties.cs
@@ -379,8 +379,8 @@ public override UnicastIPAddressInformationCollection GetUnicastAddresses() =>
         public override async Task<UnicastIPAddressInformationCollection> GetUnicastAddressesAsync()
         {
             // Wait for the address table to stabilize.
-            var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-            if (!TeredoHelper.UnsafeNotifyStableUnicastIpAddressTable(s => ((TaskCompletionSource<bool>)s).TrySetResult(true), tcs))
+            var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            if (!TeredoHelper.UnsafeNotifyStableUnicastIpAddressTable(s => ((TaskCompletionSource)s).TrySetResult(), tcs))
             {
                 await tcs.Task.ConfigureAwait(false);
             }

From 3b5311aad872f188e974bf5a4b31577063c056fc Mon Sep 17 00:00:00 2001
From: Dan Moseley <danmose@microsoft.com>
Date: Fri, 28 Jan 2022 10:04:20 -0700
Subject: [PATCH 148/161] Fix BigInteger outerloop test failure (#64402)

---
 .../src/System/Numerics/BigNumber.cs             |  2 +-
 .../tests/BigInteger/parse.cs                    | 16 +++++++++++++---
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs
index 79d11ebe76203e..984bde00e7cb27 100644
--- a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs
+++ b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs
@@ -317,7 +317,7 @@ internal static bool TryValidateParseStyleInteger(NumberStyles style, [NotNullWh
             { // Check for hex number
                 if ((style & ~NumberStyles.HexNumber) != 0)
                 {
-                    e = new ArgumentException(SR.Argument_InvalidHexStyle);
+                    e = new ArgumentException(SR.Argument_InvalidHexStyle, nameof(style));
                     return false;
                 }
             }
diff --git a/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs b/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs
index 115a61366d093c..7f0f427e4e5e26 100644
--- a/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs
+++ b/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs
@@ -18,7 +18,7 @@ public class parseTest
 
         // Invariant culture is commonly used for (de-)serialization and similar to en-US
         // Ukrainian (Ukraine) added to catch regressions (https://github.com/dotnet/runtime/issues/14545)
-        // Current cultue to get additional value out of glob/loc test runs
+        // Current culture to get additional value out of glob/loc test runs
         public static IEnumerable<object[]> Cultures
         {
             get
@@ -66,11 +66,11 @@ public static void RunParseToStringTests(CultureInfo culture)
                 //invalid number style
                 // ******InvalidNumberStyles
                 NumberStyles invalid = (NumberStyles)0x7c00;
-                AssertExtensions.Throws<ArgumentException>(null, () =>
+                AssertExtensions.Throws<ArgumentException>("style", () =>
                 {
                     BigInteger.Parse("1", invalid).ToString("d");
                 });
-                AssertExtensions.Throws<ArgumentException>(null, () =>
+                AssertExtensions.Throws<ArgumentException>("style", () =>
                 {
                     BigInteger junk;
                     BigInteger.TryParse("1", invalid, null, out junk);
@@ -116,6 +116,16 @@ public void Parse_Hex32Bits()
 
             Assert.True(BigInteger.TryParse("080000001", NumberStyles.HexNumber, null, out result));
             Assert.Equal(0x80000001u, result);
+
+            Assert.Throws<FormatException>(() =>
+            {
+                BigInteger.Parse("zzz", NumberStyles.HexNumber);
+            });
+
+            AssertExtensions.Throws<ArgumentException>("style", () =>
+            {
+                BigInteger.Parse("1", NumberStyles.AllowHexSpecifier | NumberStyles.AllowCurrencySymbol);
+            });
         }
 
         private static void RunFormatProviderParseStrings()

From d0a9a732246294ad2662275e34afa73fd8f48c24 Mon Sep 17 00:00:00 2001
From: Egor Bogatov <egorbo@gmail.com>
Date: Fri, 28 Jan 2022 21:30:08 +0300
Subject: [PATCH 149/161] Don't disable LEA for byrefs (#64444)

---
 src/coreclr/jit/lower.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/coreclr/jit/lower.cpp b/src/coreclr/jit/lower.cpp
index ed71bb09c4aa56..b111d73db6a995 100644
--- a/src/coreclr/jit/lower.cpp
+++ b/src/coreclr/jit/lower.cpp
@@ -4906,7 +4906,7 @@ bool Lowering::TryCreateAddrMode(GenTree* addr, bool isContainable, GenTree* par
     }
 
 #ifdef TARGET_ARM64
-    if (parent->OperIsIndir() && parent->AsIndir()->IsVolatile())
+    if (parent->OperIsIndir() && parent->AsIndir()->IsVolatile() && !varTypeIsGC(addr))
     {
         // For Arm64 we avoid using LEA for volatile INDs
         // because we won't be able to use ldar/star

From f2538c6ce048ce028717f580c5b55d16796657b6 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 28 Jan 2022 11:04:31 -0800
Subject: [PATCH 150/161] Expand System.Runtime.InteropServices.NFloat to
 support the APIs required by Xamarin (#64234)

* Expand System.Runtime.InteropServices.NFloat to support the APIs required by Xamarin

* Apply suggestions from code review

Co-authored-by: Rolf Bjarne Kvinge <rolf@xamarin.com>

* Adding NFloat tests (p1)

* Temporarily disable negative conversions involving nfloat->nint

* Adjusting the skip condition for the Mono failures

* Adding additional tests covering the NFloat.Is* APIs

* Fixing the IsNormal and IsSubnormal test to account for 64-bit vs 32-bit

Co-authored-by: Rolf Bjarne Kvinge <rolf@xamarin.com>
---
 .../src/Resources/Strings.resx                |   3 +
 .../System/Runtime/InteropServices/NFloat.cs  | 700 ++++++++++++++-
 .../ref/System.Runtime.InteropServices.cs     | 112 ++-
 .../Runtime/InteropServices/NFloatTests.cs    | 839 +++++++++++++++++-
 4 files changed, 1585 insertions(+), 69 deletions(-)

diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
index 383660c6f9a920..8b532738e4fe85 100644
--- a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -528,6 +528,9 @@
   <data name="Arg_MustBeInterface" xml:space="preserve">
     <value>Type passed must be an interface.</value>
   </data>
+  <data name="Arg_MustBeNFloat" xml:space="preserve">
+    <value>Object must be of type NFloat.</value>
+  </data>
   <data name="Arg_MustBePointer" xml:space="preserve">
     <value>Type must be a Pointer.</value>
   </data>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs
index e3cb842f2a5294..62d9a8d30e1a33 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NFloat.cs
@@ -2,7 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using Internal.Runtime.CompilerServices;
 
 #pragma warning disable SA1121 // We use our own aliases since they differ per platform
 #if TARGET_32BIT
@@ -13,65 +17,691 @@
 
 namespace System.Runtime.InteropServices
 {
-    /// <summary>
-    /// <see cref="NFloat"/> is an immutable value type that represents a floating type that has the same size
-    /// as the native integer size.
-    /// It is meant to be used as an exchange type at the managed/unmanaged boundary to accurately represent
-    /// in managed code unmanaged APIs that use a type alias for C or C++'s <c>float</c> on 32-bit platforms
-    /// or <c>double</c> on 64-bit platforms, such as the CGFloat type in libraries provided by Apple.
-    /// </summary>
+    /// <summary>Defines an immutable value type that represents a floating type that has the same size as the native integer size.</summary>
+    /// <remarks>It is meant to be used as an exchange type at the managed/unmanaged boundary to accurately represent in managed code unmanaged APIs that use a type alias for C or C++'s <c>float</c> on 32-bit platforms or <c>double</c> on 64-bit platforms, such as the CGFloat type in libraries provided by Apple.</remarks>
     [Intrinsic]
-    public readonly struct NFloat : IEquatable<NFloat>
+    public readonly struct NFloat
+        : IComparable,
+          IComparable<NFloat>,
+          IEquatable<NFloat>,
+          ISpanFormattable
     {
+        private const NumberStyles DefaultNumberStyles = NumberStyles.Float | NumberStyles.AllowThousands;
+
         private readonly NativeType _value;
 
-        /// <summary>
-        /// Constructs an instance from a 32-bit floating point value.
-        /// </summary>
-        /// <param name="value">The floating-point vaule.</param>
+        /// <summary>Constructs an instance from a 32-bit floating point value.</summary>
+        /// <param name="value">The floating-point value.</param>
+        [NonVersionable]
         public NFloat(float value)
         {
             _value = value;
         }
 
-        /// <summary>
-        /// Constructs an instance from a 64-bit floating point value.
-        /// </summary>
-        /// <param name="value">The floating-point vaule.</param>
+        /// <summary>Constructs an instance from a 64-bit floating point value.</summary>
+        /// <param name="value">The floating-point value.</param>
+        [NonVersionable]
         public NFloat(double value)
         {
             _value = (NativeType)value;
         }
 
-        /// <summary>
-        /// The underlying floating-point value of this instance.
-        /// </summary>
-        public double Value => _value;
+        /// <summary>Represents the smallest positive NFloat value that is greater than zero.</summary>
+        public static NFloat Epsilon
+        {
+            [NonVersionable]
+            get => new NFloat(NativeType.Epsilon);
+        }
+
+        /// <summary>Represents the largest finite value of a NFloat.</summary>
+        public static NFloat MaxValue
+        {
+            [NonVersionable]
+            get => new NFloat(NativeType.MaxValue);
+        }
+
+        /// <summary>Represents the smallest finite value of a NFloat.</summary>
+        public static NFloat MinValue
+        {
+            [NonVersionable]
+            get => new NFloat(NativeType.MinValue);
+        }
+
+        /// <summary>Represents a value that is not a number (NaN).</summary>
+        public static NFloat NaN
+        {
+            [NonVersionable]
+            get => new NFloat(NativeType.NaN);
+        }
+
+        /// <summary>Represents negative infinity.</summary>
+        public static NFloat NegativeInfinity
+        {
+            [NonVersionable]
+            get => new NFloat(NativeType.NegativeInfinity);
+        }
+
+        /// <summary>Represents positive infinity.</summary>
+        public static NFloat PositiveInfinity
+        {
+            [NonVersionable]
+            get => new NFloat(NativeType.PositiveInfinity);
+        }
+
+        /// <summary>Gets the size, in bytes, of an NFloat.</summary>
+        public static int Size
+        {
+            [NonVersionable]
+            get => sizeof(NativeType);
+        }
+
+        /// <summary>The underlying floating-point value of this instance.</summary>
+        public double Value
+        {
+            [NonVersionable]
+            get => _value;
+        }
+
+        //
+        // Unary Arithmetic
+        //
+
+        /// <summary>Computes the unary plus of a value.</summary>
+        /// <param name="value">The value for which to compute its unary plus.</param>
+        /// <returns>The unary plus of <paramref name="value" />.</returns>
+        [NonVersionable]
+        public static NFloat operator +(NFloat value) => value;
+
+        /// <summary>Computes the unary negation of a value.</summary>
+        /// <param name="value">The value for which to compute its unary negation.</param>
+        /// <returns>The unary negation of <paramref name="value" />.</returns>
+        [NonVersionable]
+        public static NFloat operator -(NFloat value) => new NFloat(-value._value);
+
+        /// <summary>Increments a value.</summary>
+        /// <param name="value">The value to increment.</param>
+        /// <returns>The result of incrementing <paramref name="value" />.</returns>
+        [NonVersionable]
+        public static NFloat operator ++(NFloat value) => new NFloat(value._value + 1);
+
+        /// <summary>Decrements a value.</summary>
+        /// <param name="value">The value to decrement.</param>
+        /// <returns>The result of decrementing <paramref name="value" />.</returns>
+        [NonVersionable]
+        public static NFloat operator --(NFloat value) => new NFloat(value._value - 1);
+
+        //
+        // Binary Arithmetic
+        //
+
+        /// <summary>Adds two values together to compute their sum.</summary>
+        /// <param name="left">The value to which <paramref name="right" /> is added.</param>
+        /// <param name="right">The value which is added to <paramref name="left" />.</param>
+        /// <returns>The sum of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [NonVersionable]
+        public static NFloat operator +(NFloat left, NFloat right) => new NFloat(left._value + right._value);
+
+        /// <summary>Subtracts two values to compute their difference.</summary>
+        /// <param name="left">The value from which <paramref name="right" /> is subtracted.</param>
+        /// <param name="right">The value which is subtracted from <paramref name="left" />.</param>
+        /// <returns>The difference of <paramref name="right" /> subtracted from <paramref name="left" />.</returns>
+        [NonVersionable]
+        public static NFloat operator -(NFloat left, NFloat right) => new NFloat(left._value - right._value);
+
+        /// <summary>Multiplies two values together to compute their product.</summary>
+        /// <param name="left">The value which <paramref name="right" /> multiplies.</param>
+        /// <param name="right">The value which multiplies <paramref name="left" />.</param>
+        /// <returns>The product of <paramref name="left" /> divided-by <paramref name="right" />.</returns>
+        [NonVersionable]
+        public static NFloat operator *(NFloat left, NFloat right) => new NFloat(left._value * right._value);
+
+        /// <summary>Divides two values together to compute their quotient.</summary>
+        /// <param name="left">The value which <paramref name="right" /> divides.</param>
+        /// <param name="right">The value which divides <paramref name="left" />.</param>
+        /// <returns>The quotient of <paramref name="left" /> divided-by <paramref name="right" />.</returns>
+        [NonVersionable]
+        public static NFloat operator /(NFloat left, NFloat right) => new NFloat(left._value / right._value);
+
+        /// <summary>Divides two values together to compute their remainder.</summary>
+        /// <param name="left">The value which <paramref name="right" /> divides.</param>
+        /// <param name="right">The value which divides <paramref name="left" />.</param>
+        /// <returns>The remainder of <paramref name="left" /> divided-by <paramref name="right" />.</returns>
+        [NonVersionable]
+        public static NFloat operator %(NFloat left, NFloat right) => new NFloat(left._value % right._value);
+
+        //
+        // Comparisons
+        //
+
+        /// <summary>Compares two values to determine equality.</summary>
+        /// <param name="left">The value to compare with <paramref name="right" />.</param>
+        /// <param name="right">The value to compare with <paramref name="left" />.</param>
+        /// <returns><c>true</c> if <paramref name="left" /> is equal to <paramref name="right" />; otherwise, <c>false</c>.</returns>
+        [NonVersionable]
+        public static bool operator ==(NFloat left, NFloat right) => left._value == right._value;
+
+        /// <summary>Compares two values to determine inequality.</summary>
+        /// <param name="left">The value to compare with <paramref name="right" />.</param>
+        /// <param name="right">The value to compare with <paramref name="left" />.</param>
+        /// <returns><c>true</c> if <paramref name="left" /> is not equal to <paramref name="right" />; otherwise, <c>false</c>.</returns>
+        [NonVersionable]
+        public static bool operator !=(NFloat left, NFloat right) => left._value != right._value;
+
+        /// <summary>Compares two values to determine which is less.</summary>
+        /// <param name="left">The value to compare with <paramref name="right" />.</param>
+        /// <param name="right">The value to compare with <paramref name="left" />.</param>
+        /// <returns><c>true</c> if <paramref name="left" /> is less than <paramref name="right" />; otherwise, <c>false</c>.</returns>
+        [NonVersionable]
+        public static bool operator <(NFloat left, NFloat right) => left._value < right._value;
+
+        /// <summary>Compares two values to determine which is less or equal.</summary>
+        /// <param name="left">The value to compare with <paramref name="right" />.</param>
+        /// <param name="right">The value to compare with <paramref name="left" />.</param>
+        /// <returns><c>true</c> if <paramref name="left" /> is less than or equal to <paramref name="right" />; otherwise, <c>false</c>.</returns>
+        [NonVersionable]
+        public static bool operator <=(NFloat left, NFloat right) => left._value <= right._value;
+
+        /// <summary>Compares two values to determine which is greater.</summary>
+        /// <param name="left">The value to compare with <paramref name="right" />.</param>
+        /// <param name="right">The value to compare with <paramref name="left" />.</param>
+        /// <returns><c>true</c> if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, <c>false</c>.</returns>
+        [NonVersionable]
+        public static bool operator >(NFloat left, NFloat right) => left._value > right._value;
+
+        /// <summary>Compares two values to determine which is greater or equal.</summary>
+        /// <param name="left">The value to compare with <paramref name="right" />.</param>
+        /// <param name="right">The value to compare with <paramref name="left" />.</param>
+        /// <returns><c>true</c> if <paramref name="left" /> is greater than or equal to <paramref name="right" />; otherwise, <c>false</c>.</returns>
+        [NonVersionable]
+        public static bool operator >=(NFloat left, NFloat right) => left._value >= right._value;
+
+        //
+        // Explicit Convert To NFloat
+        //
+
+        /// <summary>Explicitly converts a <see cref="System.Decimal" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static explicit operator NFloat(decimal value) => new NFloat((NativeType)value);
+
+        /// <summary>Explicitly converts a <see cref="System.Double" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static explicit operator NFloat(double value) => new NFloat((NativeType)value);
+
+        //
+        // Explicit Convert From NFloat
+        //
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Byte" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Byte" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator byte(NFloat value) => (byte)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Char" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Char" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator char(NFloat value) => (char)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Decimal" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Decimal" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator decimal(NFloat value) => (decimal)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Int16" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Int16" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator short(NFloat value) => (short)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Int32" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Int32" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator int(NFloat value) => (int)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Int64" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Int64" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator long(NFloat value) => (long)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.IntPtr" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.IntPtr" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator nint(NFloat value) => (nint)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.SByte" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.SByte" /> value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static explicit operator sbyte(NFloat value) => (sbyte)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Single" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Single" /> value.</returns>
+        [NonVersionable]
+        public static explicit operator float(NFloat value) => (float)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.UInt16" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.UInt16" /> value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static explicit operator ushort(NFloat value) => (ushort)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.UInt32" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.UInt32" /> value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static explicit operator uint(NFloat value) => (uint)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.UInt64" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.UInt64" /> value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static explicit operator ulong(NFloat value) => (ulong)(value._value);
+
+        /// <summary>Explicitly converts a native-sized floating-point value to its nearest representable <see cref="System.UIntPtr" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.UIntPtr" /> value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static explicit operator nuint(NFloat value) => (nuint)(value._value);
+
+        //
+        // Implicit Convert To NFloat
+        //
 
-        /// <summary>
-        /// Returns a value indicating whether this instance is equal to a specified object.
-        /// </summary>
-        /// <param name="o">An object to compare with this instance.</param>
-        /// <returns><c>true</c> if <paramref name="o"/> is an instance of <see cref="NFloat"/> and equals the value of this instance; otherwise, <c>false</c>.</returns>
-        public override bool Equals([NotNullWhen(true)] object? o) => o is NFloat other && Equals(other);
+        /// <summary>Implicitly converts a <see cref="System.Byte" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static implicit operator NFloat(byte value) => new NFloat((NativeType)value);
 
-        /// <summary>
-        /// Returns a value indicating whether this instance is equal to a specified <see cref="CLong"/> value.
-        /// </summary>
+        /// <summary>Implicitly converts a <see cref="System.Char" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static implicit operator NFloat(char value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.Int16" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static implicit operator NFloat(short value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.Int32" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static implicit operator NFloat(int value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.Int64" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static implicit operator NFloat(long value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.IntPtr" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static implicit operator NFloat(nint value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.SByte" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static implicit operator NFloat(sbyte value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.Single" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        public static implicit operator NFloat(float value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.UInt16" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static implicit operator NFloat(ushort value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.UInt32" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static implicit operator NFloat(uint value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.UInt64" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static implicit operator NFloat(ulong value) => new NFloat((NativeType)value);
+
+        /// <summary>Implicitly converts a <see cref="System.UIntPtr" /> value to its nearest representable native-sized floating-point value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable native-sized floating-point value.</returns>
+        [NonVersionable]
+        [CLSCompliant(false)]
+        public static implicit operator NFloat(nuint value) => new NFloat((NativeType)value);
+
+        //
+        // Implicit Convert From NFloat
+        //
+
+        /// <summary>Implicitly converts a native-sized floating-point value to its nearest representable <see cref="System.Double" /> value.</summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns><paramref name="value" /> converted to its nearest representable <see cref="System.Double" /> value.</returns>
+        public static implicit operator double(NFloat value) => (double)(value._value);
+
+        /// <summary>Determines whether the specified value is finite (zero, subnormal, or normal).</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is finite (zero, subnormal or normal); <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsFinite(NFloat value) => NativeType.IsFinite(value._value);
+
+        /// <summary>Determines whether the specified value is infinite (positive or negative infinity).</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is infinite (positive or negative infinity); <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsInfinity(NFloat value) => NativeType.IsInfinity(value._value);
+
+        /// <summary>Determines whether the specified value is NaN (not a number).</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is NaN (not a number); <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsNaN(NFloat value) => NativeType.IsNaN(value._value);
+
+        /// <summary>Determines whether the specified value is negative.</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is negative; <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsNegative(NFloat value) => NativeType.IsNegative(value._value);
+
+        /// <summary>Determines whether the specified value is negative infinity.</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is negative infinity; <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsNegativeInfinity(NFloat value) => NativeType.IsNegativeInfinity(value._value);
+
+        /// <summary>Determines whether the specified value is normal.</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is normal; <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsNormal(NFloat value) => NativeType.IsNormal(value._value);
+
+        /// <summary>Determines whether the specified value is positive infinity.</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is positive infinity; <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsPositiveInfinity(NFloat value) => NativeType.IsPositiveInfinity(value._value);
+
+        /// <summary>Determines whether the specified value is subnormal.</summary>
+        /// <param name="value">The floating-point value.</param>
+        /// <returns><c>true</c> if the value is subnormal; <c>false</c> otherwise.</returns>
+        [NonVersionable]
+        public static bool IsSubnormal(NFloat value) => NativeType.IsSubnormal(value._value);
+
+        /// <summary>Converts the string representation of a number to its floating-point number equivalent.</summary>
+        /// <param name="s">A string that contains the number to convert.</param>
+        /// <returns>A floating-point number that is equivalent to the numeric value or symbol specified in <paramref name="s" />.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="s" /> is <c>null</c>.</exception>
+        /// <exception cref="FormatException"><paramref name="s" /> does not represent a number in a valid format.</exception>
+        public static NFloat Parse(string s)
+        {
+            var result = NativeType.Parse(s);
+            return new NFloat(result);
+        }
+
+        /// <summary>Converts the string representation of a number in a specified style to its floating-point number equivalent.</summary>
+        /// <param name="s">A string that contains the number to convert.</param>
+        /// <param name="style">A bitwise combination of enumeration values that indicate the style elements that can be present in <paramref name="s" />.</param>
+        /// <returns>A floating-point number that is equivalent to the numeric value or symbol specified in <paramref name="s" />.</returns>
+        /// <exception cref="ArgumentException">
+        ///    <para><paramref name="style" /> is not a <see cref="NumberStyles" /> value.</para>
+        ///    <para>-or-</para>
+        ///    <para><paramref name="style" /> includes the <see cref="NumberStyles.AllowHexSpecifier" /> value.</para>
+        /// </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="s" /> is <c>null</c>.</exception>
+        /// <exception cref="FormatException"><paramref name="s" /> does not represent a number in a valid format.</exception>
+        public static NFloat Parse(string s, NumberStyles style)
+        {
+            var result = NativeType.Parse(s, style);
+            return new NFloat(result);
+        }
+
+        /// <summary>Converts the string representation of a number in a specified culture-specific format to its floating-point number equivalent.</summary>
+        /// <param name="s">A string that contains the number to convert.</param>
+        /// <param name="provider">An object that supplies culture-specific formatting information about <paramref name="s" />.</param>
+        /// <returns>A floating-point number that is equivalent to the numeric value or symbol specified in <paramref name="s" />.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="s" /> is <c>null</c>.</exception>
+        /// <exception cref="FormatException"><paramref name="s" /> does not represent a number in a valid format.</exception>
+        public static NFloat Parse(string s, IFormatProvider? provider)
+        {
+            var result = NativeType.Parse(s, provider);
+            return new NFloat(result);
+        }
+
+        /// <summary>Converts the string representation of a number in a specified style and culture-specific format to its floating-point number equivalent.</summary>
+        /// <param name="s">A string that contains the number to convert.</param>
+        /// <param name="style">A bitwise combination of enumeration values that indicate the style elements that can be present in <paramref name="s" />.</param>
+        /// <param name="provider">An object that supplies culture-specific formatting information about <paramref name="s" />.</param>
+        /// <returns>A floating-point number that is equivalent to the numeric value or symbol specified in <paramref name="s" />.</returns>
+        /// <exception cref="ArgumentException">
+        ///    <para><paramref name="style" /> is not a <see cref="NumberStyles" /> value.</para>
+        ///    <para>-or-</para>
+        ///    <para><paramref name="style" /> includes the <see cref="NumberStyles.AllowHexSpecifier" /> value.</para>
+        /// </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="s" /> is <c>null</c>.</exception>
+        /// <exception cref="FormatException"><paramref name="s" /> does not represent a number in a valid format.</exception>
+        public static NFloat Parse(string s, NumberStyles style, IFormatProvider? provider)
+        {
+            var result = NativeType.Parse(s, style, provider);
+            return new NFloat(result);
+        }
+
+        /// <summary>Converts a character span that contains the string representation of a number in a specified style and culture-specific format to its floating-point number equivalent.</summary>
+        /// <param name="s">A character span that contains the number to convert.</param>
+        /// <param name="style">A bitwise combination of enumeration values that indicate the style elements that can be present in <paramref name="s" />.</param>
+        /// <param name="provider">An object that supplies culture-specific formatting information about <paramref name="s" />.</param>
+        /// <returns>A floating-point number that is equivalent to the numeric value or symbol specified in <paramref name="s" />.</returns>
+        /// <exception cref="ArgumentException">
+        ///    <para><paramref name="style" /> is not a <see cref="NumberStyles" /> value.</para>
+        ///    <para>-or-</para>
+        ///    <para><paramref name="style" /> includes the <see cref="NumberStyles.AllowHexSpecifier" /> value.</para>
+        /// </exception>
+        /// <exception cref="FormatException"><paramref name="s" /> does not represent a number in a valid format.</exception>
+        public static NFloat Parse(ReadOnlySpan<char> s, NumberStyles style = DefaultNumberStyles, IFormatProvider? provider = null)
+        {
+            var result = NativeType.Parse(s, style, provider);
+            return new NFloat(result);
+        }
+
+        /// <summary>Tries to convert the string representation of a number to its floating-point number equivalent.</summary>
+        /// <param name="s">A read-only character span that contains the number to convert.</param>
+        /// <param name="result">When this method returns, contains a floating-point number equivalent of the numeric value or symbol contained in <paramref name="s" /> if the conversion succeeded or zero if the conversion failed. The conversion fails if the <paramref name="s" /> is <c>null</c>, <see cref="string.Empty" />, or is not in a valid format. This parameter is passed uninitialized; any value originally supplied in result will be overwritten.</param>
+        /// <returns><c>true</c> if <paramref name="s" /> was converted successfully; otherwise, false.</returns>
+        public static bool TryParse([NotNullWhen(true)] string? s, out NFloat result)
+        {
+            Unsafe.SkipInit(out result);
+            return NativeType.TryParse(s, out Unsafe.As<NFloat, NativeType>(ref result));
+        }
+
+        /// <summary>Tries to convert a character span containing the string representation of a number to its floating-point number equivalent.</summary>
+        /// <param name="s">A read-only character span that contains the number to convert.</param>
+        /// <param name="result">When this method returns, contains a floating-point number equivalent of the numeric value or symbol contained in <paramref name="s" /> if the conversion succeeded or zero if the conversion failed. The conversion fails if the <paramref name="s" /> is <see cref="string.Empty" /> or is not in a valid format. This parameter is passed uninitialized; any value originally supplied in result will be overwritten.</param>
+        /// <returns><c>true</c> if <paramref name="s" /> was converted successfully; otherwise, false.</returns>
+        public static bool TryParse(ReadOnlySpan<char> s, out NFloat result)
+        {
+            Unsafe.SkipInit(out result);
+            return NativeType.TryParse(s, out Unsafe.As<NFloat, NativeType>(ref result));
+        }
+
+        /// <summary>Tries to convert the string representation of a number in a specified style and culture-specific format to its floating-point number equivalent.</summary>
+        /// <param name="s">A read-only character span that contains the number to convert.</param>
+        /// <param name="style">A bitwise combination of enumeration values that indicate the style elements that can be present in <paramref name="s" />.</param>
+        /// <param name="provider">An object that supplies culture-specific formatting information about <paramref name="s" />.</param>
+        /// <param name="result">When this method returns, contains a floating-point number equivalent of the numeric value or symbol contained in <paramref name="s" /> if the conversion succeeded or zero if the conversion failed. The conversion fails if the <paramref name="s" /> is <c>null</c>, <see cref="string.Empty" />, or is not in a format compliant with <paramref name="style" />, or if <paramref name="style" /> is not a valid combination of <see cref="NumberStyles" /> enumeration constants. This parameter is passed uninitialized; any value originally supplied in result will be overwritten.</param>
+        /// <returns><c>true</c> if <paramref name="s" /> was converted successfully; otherwise, false.</returns>
+        /// <exception cref="ArgumentException">
+        ///    <para><paramref name="style" /> is not a <see cref="NumberStyles" /> value.</para>
+        ///    <para>-or-</para>
+        ///    <para><paramref name="style" /> includes the <see cref="NumberStyles.AllowHexSpecifier" /> value.</para>
+        /// </exception>
+        public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out NFloat result)
+        {
+            Unsafe.SkipInit(out result);
+            return NativeType.TryParse(s, style, provider, out Unsafe.As<NFloat, NativeType>(ref result));
+        }
+
+        /// <summary>Tries to convert a character span containing the string representation of a number in a specified style and culture-specific format to its floating-point number equivalent.</summary>
+        /// <param name="s">A read-only character span that contains the number to convert.</param>
+        /// <param name="style">A bitwise combination of enumeration values that indicate the style elements that can be present in <paramref name="s" />.</param>
+        /// <param name="provider">An object that supplies culture-specific formatting information about <paramref name="s" />.</param>
+        /// <param name="result">When this method returns, contains a floating-point number equivalent of the numeric value or symbol contained in <paramref name="s" /> if the conversion succeeded or zero if the conversion failed. The conversion fails if the <paramref name="s" /> is <see cref="string.Empty" /> or is not in a format compliant with <paramref name="style" />, or if <paramref name="style" /> is not a valid combination of <see cref="NumberStyles" /> enumeration constants. This parameter is passed uninitialized; any value originally supplied in result will be overwritten.</param>
+        /// <returns><c>true</c> if <paramref name="s" /> was converted successfully; otherwise, false.</returns>
+        /// <exception cref="ArgumentException">
+        ///    <para><paramref name="style" /> is not a <see cref="NumberStyles" /> value.</para>
+        ///    <para>-or-</para>
+        ///    <para><paramref name="style" /> includes the <see cref="NumberStyles.AllowHexSpecifier" /> value.</para>
+        /// </exception>
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out NFloat result)
+        {
+            Unsafe.SkipInit(out result);
+            return NativeType.TryParse(s, style, provider, out Unsafe.As<NFloat, NativeType>(ref result));
+        }
+
+        /// <summary>Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.</summary>
+        /// <param name="obj">An object to compare, or <c>null</c>.</param>
+        /// <returns>
+        ///     <para>A signed number indicating the relative values of this instance and <paramref name="obj" />.</para>
+        ///     <list type="table">
+        ///         <listheader>
+        ///             <term>Return Value</term>
+        ///             <description>Description</description>
+        ///         </listheader>
+        ///         <item>
+        ///             <term>Less than zero</term>
+        ///             <description>This instance is less than <paramref name="obj" />, or this instance is not a number and <paramref name="obj" /> is a number.</description>
+        ///         </item>
+        ///         <item>
+        ///             <term>Zero</term>
+        ///             <description>This instance is equal to <paramref name="obj" />, or both this instance and <paramref name="obj" /> are not a number.</description>
+        ///         </item>
+        ///         <item>
+        ///             <term>Greater than zero</term>
+        ///             <description>This instance is greater than <paramref name="obj" />, or this instance is a number and <paramref name="obj" /> is not a number or <paramref name="obj" /> is <c>null</c>.</description>
+        ///         </item>
+        ///     </list>
+        /// </returns>
+        /// <exception cref="System.ArgumentException"><paramref name="obj" /> is not a <see cref="NFloat" />.</exception>
+        public int CompareTo(object? obj)
+        {
+            if (obj is NFloat other)
+            {
+                if (_value < other._value) return -1;
+                if (_value > other._value) return 1;
+                if (_value == other._value) return 0;
+
+                // At least one of the values is NaN.
+                if (NativeType.IsNaN(_value))
+                {
+                    return NativeType.IsNaN(other._value) ? 0 : -1;
+                }
+                else
+                {
+                    return 1;
+                }
+            }
+            else if (obj is null)
+            {
+                return 1;
+            }
+
+            throw new ArgumentException(SR.Arg_MustBeNFloat);
+        }
+
+        /// <summary>Compares this instance to a specified floating-point number and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified floating-point number.</summary>
+        /// <param name="other">A floating-point number to compare.</param>
+        /// <returns>
+        ///     <para>A signed number indicating the relative values of this instance and <paramref name="other" />.</para>
+        ///     <list type="table">
+        ///         <listheader>
+        ///             <term>Return Value</term>
+        ///             <description>Description</description>
+        ///         </listheader>
+        ///         <item>
+        ///             <term>Less than zero</term>
+        ///             <description>This instance is less than <paramref name="other" />, or this instance is not a number and <paramref name="other" /> is a number.</description>
+        ///         </item>
+        ///         <item>
+        ///             <term>Zero</term>
+        ///             <description>This instance is equal to <paramref name="other" />, or both this instance and <paramref name="other" /> are not a number.</description>
+        ///         </item>
+        ///         <item>
+        ///             <term>Greater than zero</term>
+        ///             <description>This instance is greater than <paramref name="other" />, or this instance is a number and <paramref name="other" /> is not a number.</description>
+        ///         </item>
+        ///     </list>
+        /// </returns>
+        public int CompareTo(NFloat other) => _value.CompareTo(other._value);
+
+        /// <summary>Returns a value indicating whether this instance is equal to a specified object.</summary>
+        /// <param name="obj">An object to compare with this instance.</param>
+        /// <returns><c>true</c> if <paramref name="obj"/> is an instance of <see cref="NFloat"/> and equals the value of this instance; otherwise, <c>false</c>.</returns>
+        public override bool Equals([NotNullWhen(true)] object? obj) => (obj is NFloat other) && Equals(other);
+
+        /// <summary>Returns a value indicating whether this instance is equal to a specified <see cref="NFloat" /> value.</summary>
         /// <param name="other">An <see cref="NFloat"/> value to compare to this instance.</param>
         /// <returns><c>true</c> if <paramref name="other"/> has the same value as this instance; otherwise, <c>false</c>.</returns>
         public bool Equals(NFloat other) => _value.Equals(other._value);
 
-        /// <summary>
-        /// Returns the hash code for this instance.
-        /// </summary>
+        /// <summary>Returns the hash code for this instance.</summary>
         /// <returns>A 32-bit signed integer hash code.</returns>
         public override int GetHashCode() => _value.GetHashCode();
 
-        /// <summary>
-        /// Converts the numeric value of this instance to its equivalent string representation.
-        /// </summary>
+        /// <summary>Converts the numeric value of this instance to its equivalent string representation.</summary>
         /// <returns>The string representation of the value of this instance.</returns>
         public override string ToString() => _value.ToString();
+
+        /// <summary>Converts the numeric value of this instance to its equivalent string representation using the specified format.</summary>
+        /// <param name="format">A numeric format string.</param>
+        /// <returns>The string representation of the value of this instance as specified by <paramref name="format" />.</returns>
+        /// <exception cref="FormatException"><paramref name="format" /> is invalid.</exception>
+        public string ToString(string? format) => _value.ToString(format);
+
+        /// <summary>Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.</summary>
+        /// <param name="provider">An object that supplies culture-specific formatting information.</param>
+        /// <returns>The string representation of the value of this instance as specified by <paramref name="provider" />.</returns>
+        public string ToString(IFormatProvider? provider)=> _value.ToString(provider);
+
+        /// <summary>Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.</summary>
+        /// <param name="format">A numeric format string.</param>
+        /// <param name="provider">An object that supplies culture-specific formatting information.</param>
+        /// <returns>The string representation of the value of this instance as specified by <paramref name="format" /> and <paramref name="provider" />.</returns>
+        /// <exception cref="FormatException"><paramref name="format" /> is invalid.</exception>
+        public string ToString(string? format, IFormatProvider? provider) => _value.ToString(format, provider);
+
+        /// <summary>Tries to format the value of the current instance into the provided span of characters.</summary>
+        /// <param name="destination">The span in which to write this instance's value formatted as a span of characters.</param>
+        /// <param name="charsWritten">When this method returns, contains the number of characters that were written in <paramref name="destination" />.</param>
+        /// <param name="format">A span containing the characters that represent a standard or custom format string that defines the acceptable format for <paramref name="destination" />.</param>
+        /// <param name="provider">An optional object that supplies culture-specific formatting information for <paramref name="destination" />.</param>
+        /// <returns><c>true</c> if the formatting was successful; otherwise, <c>false</c>.</returns>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default, IFormatProvider? provider = null) => _value.TryFormat(destination, out charsWritten, format, provider);
     }
 }
diff --git a/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs b/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
index e58de5b8a040a9..d56bf7a1737d4e 100644
--- a/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
+++ b/src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs
@@ -157,13 +157,14 @@ public enum ClassInterfaceType
         AutoDual = 2,
     }
     [System.CLSCompliantAttribute(false)]
-    public readonly struct CLong : IEquatable<CLong>
+    public readonly partial struct CLong : System.IEquatable<System.Runtime.InteropServices.CLong>
     {
-        public CLong(int value) { }
-        public CLong(nint value) { }
+        private readonly int _dummyPrimitive;
+        public CLong(int value) { throw null; }
+        public CLong(nint value) { throw null; }
         public nint Value { get { throw null; } }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? o) { throw null; }
-        public bool Equals(CLong other) { throw null; }
+        public bool Equals(System.Runtime.InteropServices.CLong other) { throw null; }
         public override int GetHashCode() { throw null; }
         public override string ToString() { throw null; }
     }
@@ -294,13 +295,14 @@ public sealed partial class ComUnregisterFunctionAttribute : System.Attribute
         public ComUnregisterFunctionAttribute() { }
     }
     [System.CLSCompliantAttribute(false)]
-    public readonly struct CULong : IEquatable<CULong>
+    public readonly partial struct CULong : System.IEquatable<System.Runtime.InteropServices.CULong>
     {
-        public CULong(uint value) { }
-        public CULong(nuint value) { }
+        private readonly int _dummyPrimitive;
+        public CULong(uint value) { throw null; }
+        public CULong(nuint value) { throw null; }
         public nuint Value { get { throw null; } }
         public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? o) { throw null; }
-        public bool Equals(CULong other) { throw null; }
+        public bool Equals(System.Runtime.InteropServices.CULong other) { throw null; }
         public override int GetHashCode() { throw null; }
         public override string ToString() { throw null; }
     }
@@ -782,15 +784,99 @@ public static void Free(void* ptr) { }
         [System.CLSCompliantAttribute(false)]
         public static void* Realloc(void* ptr, nuint byteCount) { throw null; }
     }
-    public readonly struct NFloat : IEquatable<NFloat>
+    public readonly partial struct NFloat : System.IComparable, System.IComparable<System.Runtime.InteropServices.NFloat>, System.IEquatable<System.Runtime.InteropServices.NFloat>, System.IFormattable, System.ISpanFormattable
     {
-        public NFloat(float value) { }
-        public NFloat(double value) { }
+        private readonly int _dummyPrimitive;
+        public NFloat(double value) { throw null; }
+        public NFloat(float value) { throw null; }
+        public static System.Runtime.InteropServices.NFloat Epsilon { get { throw null; } }
+        public static System.Runtime.InteropServices.NFloat MaxValue { get { throw null; } }
+        public static System.Runtime.InteropServices.NFloat MinValue { get { throw null; } }
+        public static System.Runtime.InteropServices.NFloat NaN { get { throw null; } }
+        public static System.Runtime.InteropServices.NFloat NegativeInfinity { get { throw null; } }
+        public static System.Runtime.InteropServices.NFloat PositiveInfinity { get { throw null; } }
+        public static int Size { get { throw null; } }
         public double Value { get { throw null; } }
-        public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? o) { throw null; }
-        public bool Equals(NFloat other) { throw null; }
+        public int CompareTo(object? obj) { throw null; }
+        public int CompareTo(System.Runtime.InteropServices.NFloat other) { throw null; }
+        public override bool Equals([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] object? obj) { throw null; }
+        public bool Equals(System.Runtime.InteropServices.NFloat other) { throw null; }
         public override int GetHashCode() { throw null; }
+        public static bool IsFinite(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool IsInfinity(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool IsNaN(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool IsNegative(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool IsNegativeInfinity(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool IsNormal(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool IsPositiveInfinity(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool IsSubnormal(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator +(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator --(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator /(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static bool operator ==(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static explicit operator System.Runtime.InteropServices.NFloat (decimal value) { throw null; }
+        public static explicit operator System.Runtime.InteropServices.NFloat (double value) { throw null; }
+        public static explicit operator byte (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static explicit operator char (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static explicit operator decimal (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static explicit operator short (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static explicit operator int (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static explicit operator long (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static explicit operator nint (System.Runtime.InteropServices.NFloat value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static explicit operator sbyte (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static explicit operator float (System.Runtime.InteropServices.NFloat value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static explicit operator ushort (System.Runtime.InteropServices.NFloat value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static explicit operator uint (System.Runtime.InteropServices.NFloat value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static explicit operator ulong (System.Runtime.InteropServices.NFloat value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static explicit operator nuint (System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool operator >(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static bool operator >=(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static implicit operator System.Runtime.InteropServices.NFloat (byte value) { throw null; }
+        public static implicit operator System.Runtime.InteropServices.NFloat (char value) { throw null; }
+        public static implicit operator System.Runtime.InteropServices.NFloat (short value) { throw null; }
+        public static implicit operator System.Runtime.InteropServices.NFloat (int value) { throw null; }
+        public static implicit operator System.Runtime.InteropServices.NFloat (long value) { throw null; }
+        public static implicit operator System.Runtime.InteropServices.NFloat (nint value) { throw null; }
+        public static implicit operator double (System.Runtime.InteropServices.NFloat value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static implicit operator System.Runtime.InteropServices.NFloat (sbyte value) { throw null; }
+        public static implicit operator System.Runtime.InteropServices.NFloat (float value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static implicit operator System.Runtime.InteropServices.NFloat (ushort value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static implicit operator System.Runtime.InteropServices.NFloat (uint value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static implicit operator System.Runtime.InteropServices.NFloat (ulong value) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public static implicit operator System.Runtime.InteropServices.NFloat (nuint value) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator ++(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static bool operator !=(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static bool operator <(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static bool operator <=(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator %(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator *(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator -(System.Runtime.InteropServices.NFloat left, System.Runtime.InteropServices.NFloat right) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator -(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static System.Runtime.InteropServices.NFloat operator +(System.Runtime.InteropServices.NFloat value) { throw null; }
+        public static System.Runtime.InteropServices.NFloat Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowDecimalPoint | System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowLeadingSign | System.Globalization.NumberStyles.AllowLeadingWhite | System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.AllowTrailingWhite, System.IFormatProvider? provider = null) { throw null; }
+        public static System.Runtime.InteropServices.NFloat Parse(string s) { throw null; }
+        public static System.Runtime.InteropServices.NFloat Parse(string s, System.Globalization.NumberStyles style) { throw null; }
+        public static System.Runtime.InteropServices.NFloat Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider? provider) { throw null; }
+        public static System.Runtime.InteropServices.NFloat Parse(string s, System.IFormatProvider? provider) { throw null; }
         public override string ToString() { throw null; }
+        public string ToString(System.IFormatProvider? provider) { throw null; }
+        public string ToString(string? format) { throw null; }
+        public string ToString(string? format, System.IFormatProvider? provider) { throw null; }
+        public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider? provider = null) { throw null; }
+        public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider? provider, out System.Runtime.InteropServices.NFloat result) { throw null; }
+        public static bool TryParse(System.ReadOnlySpan<char> s, out System.Runtime.InteropServices.NFloat result) { throw null; }
+        public static bool TryParse([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] string? s, System.Globalization.NumberStyles style, System.IFormatProvider? provider, out System.Runtime.InteropServices.NFloat result) { throw null; }
+        public static bool TryParse([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] string? s, out System.Runtime.InteropServices.NFloat result) { throw null; }
     }
     [System.AttributeUsageAttribute(System.AttributeTargets.Parameter, Inherited=false)]
     public sealed partial class OptionalAttribute : System.Attribute
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/NFloatTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/NFloatTests.cs
index c2311afae708d1..6f97497fe03c7c 100644
--- a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/NFloatTests.cs
+++ b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/NFloatTests.cs
@@ -15,36 +15,844 @@ public class NFloatTests
         [Fact]
         public void Ctor_Empty()
         {
-            NFloat value = new NFloat();
-            Assert.Equal(0, value.Value);
+            NFloat result = new NFloat();
+            Assert.Equal(0, result.Value);
         }
 
         [Fact]
         public void Ctor_Float()
         {
-            NFloat value = new NFloat(42.0f);
-            Assert.Equal(42.0, value.Value);
+            NFloat result = new NFloat(42.0f);
+            Assert.Equal(42.0, result.Value);
         }
 
         [Fact]
         public void Ctor_Double()
         {
-            NFloat value = new NFloat(42.0);
-            Assert.Equal(42.0, value.Value);
+            NFloat result = new NFloat(42.0);
+            Assert.Equal(42.0, result.Value);
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.Is32BitProcess))]
         public void Ctor_Double_OutOfRange()
         {
-            NFloat value = new NFloat(double.MaxValue);
-            Assert.Equal((double)(float)double.MaxValue, value.Value);
+            NFloat result = new NFloat(double.MaxValue);
+            Assert.Equal(float.PositiveInfinity, result.Value);
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.Is64BitProcess))]
         public void Ctor_Double_LargeValue()
         {
-            NFloat value = new NFloat(double.MaxValue);
-            Assert.Equal(double.MaxValue, value.Value);
+            NFloat result = new NFloat(double.MaxValue);
+            Assert.Equal(double.MaxValue, result.Value);
+        }
+
+        [Fact]
+        public void Epsilon()
+        {
+            NFloat result = NFloat.Epsilon;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(double.Epsilon, result.Value);
+            }
+            else
+            {
+                Assert.Equal(float.Epsilon, result.Value);
+            }
+        }
+
+        [Fact]
+        public void MaxValue()
+        {
+            NFloat result = NFloat.MaxValue;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(double.MaxValue, result.Value);
+            }
+            else
+            {
+                Assert.Equal(float.MaxValue, result.Value);
+            }
+        }
+
+        [Fact]
+        public void MinValue()
+        {
+            NFloat result = NFloat.MinValue;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(double.MinValue, result.Value);
+            }
+            else
+            {
+                Assert.Equal(float.MinValue, result.Value);
+            }
+        }
+
+        [Fact]
+        public void NaN()
+        {
+            NFloat result = NFloat.NaN;
+            Assert.True(double.IsNaN(result.Value));
+        }
+
+        [Fact]
+        public void NegativeInfinity()
+        {
+            NFloat result = NFloat.NegativeInfinity;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(double.NegativeInfinity, result.Value);
+            }
+            else
+            {
+                Assert.Equal(float.NegativeInfinity, result.Value);
+            }
+        }
+
+        [Fact]
+        public void PositiveInfinity()
+        {
+            NFloat result = NFloat.PositiveInfinity;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(double.PositiveInfinity, result.Value);
+            }
+            else
+            {
+                Assert.Equal(float.PositiveInfinity, result.Value);
+            }
+        }
+
+        [Fact]
+        public unsafe void Size()
+        {
+            int size = PlatformDetection.Is32BitProcess ? 4 : 8;
+#pragma warning disable xUnit2000 // The value under test here is the sizeof expression
+            Assert.Equal(size, sizeof(NFloat));
+#pragma warning restore xUnit2000
+            Assert.Equal(size, Marshal.SizeOf<NFloat>());
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public static void op_UnaryPlus(float value)
+        {
+            NFloat result = +(new NFloat(value));
+            Assert.Equal(+value, result.Value);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public static void op_UnaryNegation(float value)
+        {
+            NFloat result = -(new NFloat(value));
+            Assert.Equal(-value, result.Value);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public static void op_Decrement(float value)
+        {
+            NFloat result = new NFloat(value);
+            --result;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((double)value - 1, result.Value);
+            }
+            else
+            {
+                Assert.Equal(value - 1, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public static void op_Increment(float value)
+        {
+            NFloat result = new NFloat(value);
+            ++result;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((double)value + 1, result.Value);
+            }
+            else
+            {
+                Assert.Equal(value + 1, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f, 3.14f)]
+        [InlineData(-4567.89101f, 3.14569f)]
+        [InlineData(0.0f, 3.14f)]
+        [InlineData(4567.0f, -3.14f)]
+        [InlineData(4567.89101f, -3.14569f)]
+        public static void op_Addition(float left, float right)
+        {
+            NFloat result = new NFloat(left) + new NFloat(right);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((double)left + right, result.Value);
+            }
+            else
+            {
+                Assert.Equal(left + right, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f, 3.14f)]
+        [InlineData(-4567.89101f, 3.14569f)]
+        [InlineData(0.0f, 3.14f)]
+        [InlineData(4567.0f, -3.14f)]
+        [InlineData(4567.89101f, -3.14569f)]
+        public static void op_Subtraction(float left, float right)
+        {
+            NFloat result = new NFloat(left) - new NFloat(right);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((double)left - right, result.Value);
+            }
+            else
+            {
+                Assert.Equal(left - right, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f, 3.14f)]
+        [InlineData(-4567.89101f, 3.14569f)]
+        [InlineData(0.0f, 3.14f)]
+        [InlineData(4567.0f, -3.14f)]
+        [InlineData(4567.89101f, -3.14569f)]
+        public static void op_Multiply(float left, float right)
+        {
+            NFloat result = new NFloat(left) * new NFloat(right);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((double)left * right, result.Value);
+            }
+            else
+            {
+                Assert.Equal(left * right, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f, 3.14f)]
+        [InlineData(-4567.89101f, 3.14569f)]
+        [InlineData(0.0f, 3.14f)]
+        [InlineData(4567.0f, -3.14f)]
+        [InlineData(4567.89101f, -3.14569f)]
+        public static void op_Division(float left, float right)
+        {
+            NFloat result = new NFloat(left) / new NFloat(right);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((double)left / right, result.Value);
+            }
+            else
+            {
+                Assert.Equal(left / right, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f, 3.14f)]
+        [InlineData(-4567.89101f, 3.14569f)]
+        [InlineData(0.0f, 3.14f)]
+        [InlineData(4567.0f, -3.14f)]
+        [InlineData(4567.89101f, -3.14569f)]
+        public static void op_Modulus(float left, float right)
+        {
+            NFloat result = new NFloat(left) % new NFloat(right);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((double)left % right, result.Value);
+            }
+            else
+            {
+                Assert.Equal(left % right, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(789.0f, 789.0f)]
+        [InlineData(789.0f, -789.0f)]
+        [InlineData(789.0f, 0.0f)]
+        [InlineData(789.0f, 1000.0f)]
+        public void op_Equality(float left, float right)
+        {
+            bool result = new NFloat(left) == new NFloat(right);
+            Assert.Equal(left == right, result);
+        }
+
+        [Theory]
+        [InlineData(789.0f, 789.0f)]
+        [InlineData(789.0f, -789.0f)]
+        [InlineData(789.0f, 0.0f)]
+        [InlineData(789.0f, 1000.0f)]
+        public void op_Inequality(float left, float right)
+        {
+            bool result = new NFloat(left) != new NFloat(right);
+            Assert.Equal(left != right, result);
+        }
+
+        [Theory]
+        [InlineData(789.0f, 789.0f)]
+        [InlineData(789.0f, -789.0f)]
+        [InlineData(789.0f, 0.0f)]
+        [InlineData(789.0f, 1000.0f)]
+        public void op_GreaterThan(float left, float right)
+        {
+            bool result = new NFloat(left) > new NFloat(right);
+            Assert.Equal(left > right, result);
+        }
+
+        [Theory]
+        [InlineData(789.0f, 789.0f)]
+        [InlineData(789.0f, -789.0f)]
+        [InlineData(789.0f, 0.0f)]
+        [InlineData(789.0f, 1000.0f)]
+        public void op_GreaterThanOrEqual(float left, float right)
+        {
+            bool result = new NFloat(left) >= new NFloat(right);
+            Assert.Equal(left >= right, result);
+        }
+
+        [Theory]
+        [InlineData(789.0f, 789.0f)]
+        [InlineData(789.0f, -789.0f)]
+        [InlineData(789.0f, 0.0f)]
+        [InlineData(789.0f, 1000.0f)]
+        public void op_LessThan(float left, float right)
+        {
+            bool result = new NFloat(left) < new NFloat(right);
+            Assert.Equal(left < right, result);
+        }
+
+        [Theory]
+        [InlineData(789.0f, 789.0f)]
+        [InlineData(789.0f, -789.0f)]
+        [InlineData(789.0f, 0.0f)]
+        [InlineData(789.0f, 1000.0f)]
+        public void op_LessThanOrEqual(float left, float right)
+        {
+            bool result = new NFloat(left) <= new NFloat(right);
+            Assert.Equal(left <= right, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void DoubleToNFloat(float value)
+        {
+            NFloat result = (NFloat)(double)value;
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(value, result.Value);
+            }
+            else
+            {
+                Assert.Equal((float)value, result.Value);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToByte(float value)
+        {
+            byte result = (byte)new NFloat(value);
+            Assert.Equal((byte)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToChar(float value)
+        {
+            char result = (char)new NFloat(value);
+            Assert.Equal((char)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToDecimal(float value)
+        {
+            decimal result = (decimal)new NFloat(value);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal((decimal)(double)value, result);
+            }
+            else
+            {
+                Assert.Equal((decimal)value, result);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToInt16(float value)
+        {
+            short result = (short)new NFloat(value);
+            Assert.Equal((short)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToInt32(float value)
+        {
+            int result = (int)new NFloat(value);
+            Assert.Equal((int)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToInt64(float value)
+        {
+            long result = (long)new NFloat(value);
+            Assert.Equal((long)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f, Skip = "https://github.com/dotnet/runtime/issues/64386")]
+        [InlineData(-4567.89101f, Skip = "https://github.com/dotnet/runtime/issues/64386")]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToIntPtr(float value)
+        {
+            nint result = (nint)new NFloat(value);
+            Assert.Equal((nint)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToSByte(float value)
+        {
+            sbyte result = (sbyte)new NFloat(value);
+            Assert.Equal((sbyte)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToSingle(float value)
+        {
+            float result = (float)new NFloat(value);
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToUInt16(float value)
+        {
+            ushort result = (ushort)new NFloat(value);
+            Assert.Equal((ushort)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToUInt32(float value)
+        {
+            uint result = (uint)new NFloat(value);
+            Assert.Equal((uint)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToUInt64(float value)
+        {
+            ulong result = (ulong)new NFloat(value);
+            Assert.Equal((ulong)value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToUIntPtr(float value)
+        {
+            nuint result = (nuint)new NFloat(value);
+            Assert.Equal((nuint)value, result);
+        }
+
+        [Theory]
+        [InlineData((byte)0)]
+        [InlineData((byte)5)]
+        [InlineData((byte)42)]
+        [InlineData((byte)127)]
+        [InlineData((byte)255)]
+        public void ByteToNFloat(byte value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData('A')]
+        [InlineData('B')]
+        [InlineData('C')]
+        [InlineData('D')]
+        [InlineData('E')]
+        public void CharToNFloat(char value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((short)-255)]
+        [InlineData((short)-127)]
+        [InlineData((short)0)]
+        [InlineData((short)127)]
+        [InlineData((short)255)]
+        public void Int16ToNFloat(short value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData(-255)]
+        [InlineData(-127)]
+        [InlineData(0)]
+        [InlineData(127)]
+        [InlineData(255)]
+        public void Int32ToNFloat(int value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((long)-255)]
+        [InlineData((long)-127)]
+        [InlineData((long)0)]
+        [InlineData((long)127)]
+        [InlineData((long)255)]
+        public void Int64ToNFloat(long value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((int)-255)]
+        [InlineData((int)-127)]
+        [InlineData((int)0)]
+        [InlineData((int)127)]
+        [InlineData((int)255)]
+        public void IntPtrToNFloat(int value)
+        {
+            NFloat result = (nint)value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((sbyte)-127)]
+        [InlineData((sbyte)-63)]
+        [InlineData((sbyte)0)]
+        [InlineData((sbyte)63)]
+        [InlineData((sbyte)127)]
+        public void SByteToNFloat(sbyte value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void SingleToNFloat(float value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((ushort)0)]
+        [InlineData((ushort)5)]
+        [InlineData((ushort)42)]
+        [InlineData((ushort)127)]
+        [InlineData((ushort)255)]
+        public void UInt16ToNFloat(ushort value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((uint)0)]
+        [InlineData((uint)5)]
+        [InlineData((uint)42)]
+        [InlineData((uint)127)]
+        [InlineData((uint)255)]
+        public void UInt32ToNFloat(uint value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((ulong)0)]
+        [InlineData((ulong)5)]
+        [InlineData((ulong)42)]
+        [InlineData((ulong)127)]
+        [InlineData((ulong)255)]
+        public void UInt64ToNFloat(ulong value)
+        {
+            NFloat result = value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData((uint)0)]
+        [InlineData((uint)5)]
+        [InlineData((uint)42)]
+        [InlineData((uint)127)]
+        [InlineData((uint)255)]
+        public void UIntPtrToNFloat(uint value)
+        {
+            NFloat result = (nuint)value;
+            Assert.Equal(value, result.Value);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        public void NFloatToDouble(float value)
+        {
+            double result = new NFloat(value);
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsFinite(float value)
+        {
+            bool result = NFloat.IsFinite(value);
+            Assert.Equal(float.IsFinite(value), result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsInfinity(float value)
+        {
+            bool result = NFloat.IsInfinity(value);
+            Assert.Equal(float.IsInfinity(value), result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsNaN(float value)
+        {
+            bool result = NFloat.IsNaN(value);
+            Assert.Equal(float.IsNaN(value), result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsNegative(float value)
+        {
+            bool result = NFloat.IsNegative(value);
+            Assert.Equal(float.IsNegative(value), result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsNegativeInfinity(float value)
+        {
+            bool result = NFloat.IsNegativeInfinity(value);
+            Assert.Equal(float.IsNegativeInfinity(value), result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsNormal(float value)
+        {
+            bool result = NFloat.IsNormal(value);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(double.IsNormal(value), result);
+            }
+            else
+            {
+                Assert.Equal(float.IsNormal(value), result);
+            }
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsPositiveInfinity(float value)
+        {
+            bool result = NFloat.IsPositiveInfinity(value);
+            Assert.Equal(float.IsPositiveInfinity(value), result);
+        }
+
+        [Theory]
+        [InlineData(-4567.0f)]
+        [InlineData(-4567.89101f)]
+        [InlineData(0.0f)]
+        [InlineData(4567.0f)]
+        [InlineData(4567.89101f)]
+        [InlineData(float.Epsilon)]
+        [InlineData(float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity)]
+        [InlineData(float.NaN)]
+        public void IsSubnormal(float value)
+        {
+            bool result = NFloat.IsSubnormal(value);
+
+            if (Environment.Is64BitProcess)
+            {
+                Assert.Equal(double.IsSubnormal(value), result);
+            }
+            else
+            {
+                Assert.Equal(float.IsSubnormal(value), result);
+            }
         }
 
         public static IEnumerable<object[]> EqualsData()
@@ -83,7 +891,6 @@ public void NaNEqualsTest()
         [InlineData(0.0f)]
         [InlineData(4567.0f)]
         [InlineData(4567.89101f)]
-
         [InlineData(float.NaN)]
         public static void ToStringTest64(float value)
         {
@@ -106,15 +913,5 @@ public static void ToStringTest32(float value)
 
             Assert.Equal(value.ToString(), nfloat.ToString());
         }
-
-        [Fact]
-        public unsafe void Size()
-        {
-            int size = PlatformDetection.Is32BitProcess ? 4 : 8;
-#pragma warning disable xUnit2000 // The value under test here is the sizeof expression
-            Assert.Equal(size, sizeof(NFloat));
-#pragma warning restore xUnit2000
-            Assert.Equal(size, Marshal.SizeOf<NFloat>());
-        }
     }
 }

From 91da4ac9fd3470fe4798f0151e36f1769a9e9c2c Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Fri, 28 Jan 2022 14:16:09 -0500
Subject: [PATCH 151/161] Add/use ArgumentException.ThrowIfNullOrEmpty (#64357)

Adds ArgumentException.ThrowIfNullOrEmpty and then uses it in a bunch of places around the tree.  Most of the replaced places used a resource string for the message, and I used it in places where it didn't feel like we were losing any meaningful information by centralizing on the single shared string, but I didn't use it in places where the resource string message used in the empty case conveyed something that seemed useful, e.g. a recommendation on what to use instead of an empty string.

There are a few places where I allowed for order of exception throws to change in the case where there were multiple user errors and the validation for a single argument was split, e.g. I changed a few cases of:
    ```C#
        if (arg1 is null) throw new ArgumentNullException(...);
        if (arg2 is null) throw new ArgumentNullException(...);
        if (arg1.Length == 0) throw new ArgumentException(...);
        if (arg2.Length == 0) throw new ArgumentException(...);
    ```
to:
    ```C#
        ArgumentException.ThrowIfNullOrEmpty(arg1);
        ArgumentException.ThrowIfNullOrEmpty(arg2);
    ```
even though it'll produce a different exception for `M("", null)` than it would previously.  Technically a breaking change, but given this is a case of multiple usage errors and all the exceptions are ArgumentException-based, I think it's acceptable.

I wanted to get this in before we do the massive !! conversion, as I expect !! auto-fixes will make it a bit harder to roll this out.  I explicitly did not do anything to roll out use of ArgumentNullException.ThrowIfNull, except in cases where I was modifying a method to use ArgumentException.ThrowIfNullOrEmpty, in which case for consistency I changed anything else in the function that could have been using ThrowIfNull to do so.
---
 .../System/Reflection/Emit/AssemblyBuilder.cs | 18 +---
 .../System/Reflection/Emit/FieldBuilder.cs    |  9 +-
 .../src/System/Reflection/Emit/ILGenerator.cs |  6 +-
 .../System/Reflection/Emit/MethodBuilder.cs   | 12 +--
 .../System/Reflection/Emit/ModuleBuilder.cs   | 23 +----
 .../System/Reflection/Emit/PropertyBuilder.cs |  5 +-
 .../src/System/Reflection/Emit/TypeBuilder.cs | 48 ++--------
 .../src/System/RuntimeHandles.cs              |  3 +-
 .../ECDiffieHellmanAndroid.Derive.cs          | 12 +--
 .../Cryptography/ECDiffieHellmanCng.cs        | 12 +--
 .../ECDiffieHellmanOpenSsl.Derive.cs          | 12 +--
 .../ECDiffieHellmanSecurityTransforms.cs      | 12 +--
 .../Security/Cryptography/RSAAndroid.cs       | 32 ++-----
 .../Cryptography/RSACng.SignVerify.cs         | 31 ++-----
 .../Security/Cryptography/RSAOpenSsl.cs       | 28 ++----
 .../Cryptography/RSASecurityTransforms.cs     | 32 ++-----
 .../DSA/DsaFamilySignatureFormatTests.cs      | 12 ++-
 .../ECDsa/ECDsaTests.cs                       | 15 +--
 .../ECDsa/ECDsaTests.netcoreapp.cs            |  4 +-
 .../RSA/SignVerify.cs                         | 14 ++-
 .../src/Resources/Strings.resx                |  5 +-
 .../ComponentModel/MaskedTextProvider.cs      |  5 +-
 .../src/Resources/Strings.resx                |  5 +-
 .../src/System/Diagnostics/ProcessManager.cs  |  6 +-
 .../tests/ProcessTests.cs                     |  4 +-
 .../src/Resources/Strings.resx                |  8 +-
 .../Diagnostics/DelimitedListTraceListener.cs |  6 +-
 .../tests/CtorsDelimiterTests.cs              |  4 +-
 .../src/Resources/Strings.resx                |  8 +-
 .../src/System/Diagnostics/SwitchAttribute.cs |  5 +-
 .../src/System/Diagnostics/TraceSource.cs     |  5 +-
 .../src/Resources/Strings.resx                |  6 +-
 .../src/System/IO/FileSystemAclExtensions.cs  | 16 +---
 .../src/Resources/Strings.resx                |  6 +-
 .../IO/IsolatedStorage/IsolatedStorageFile.cs | 92 +++----------------
 .../src/Resources/Strings.resx                |  8 +-
 .../IO/MemoryMappedFiles/MemoryMappedFile.cs  | 20 +---
 .../MemoryMappedFile.CreateOrOpen.Tests.cs    |  6 +-
 .../MemoryMappedFile.OpenExisting.Tests.cs    |  2 +-
 .../src/Resources/Strings.resx                |  3 -
 .../System/IO/Pipes/NamedPipeClientStream.cs  | 14 +--
 .../System/IO/Pipes/NamedPipeServerStream.cs  |  9 +-
 .../NamedPipeTest.CreateClient.cs             |  4 +-
 .../NamedPipeTest.CreateServer.cs             | 12 +--
 .../StreamReader.StringCtorTests.cs           | 20 ++--
 .../StreamWriter.StringCtorTests.cs           | 15 ++-
 .../src/Resources/Strings.resx                | 10 +-
 .../src/System/Net/Mail/Attachment.cs         | 20 +---
 .../src/System/Net/Mail/MailAddress.cs        | 13 +--
 .../System/Net/Mail/MailAddressCollection.cs  |  9 +-
 .../src/System/Net/Mail/MailMessage.cs        | 13 +--
 .../src/System/Net/Mail/MailPriority.cs       | 13 +--
 .../src/System/Net/Mail/SmtpClient.cs         | 10 +-
 .../src/System/Net/Mime/ContentDisposition.cs |  9 +-
 .../src/System/Net/Mime/ContentType.cs        | 19 +---
 .../src/System/Net/Mime/HeaderCollection.cs   | 69 ++------------
 .../src/System/Net/CredentialCache.cs         | 30 +-----
 .../src/System/Net/DnsEndPoint.cs             | 10 +-
 .../tests/FunctionalTests/DnsEndPointTest.cs  |  4 +-
 .../src/Resources/Strings.resx                |  3 -
 .../ServiceNameCollection.cs                  |  5 +-
 .../ServiceNameCollectionTest.cs              | 36 ++++----
 .../src/Resources/Strings.resx                |  6 +-
 .../src/System/Net/WebHeaderCollection.cs     |  9 +-
 .../src/Resources/Strings.resx                |  9 --
 .../System.Private.CoreLib.Shared.projitems   | 10 +-
 .../src/System/AppContext.cs                  | 10 +-
 .../src/System/AppDomain.cs                   |  9 +-
 .../src/System/ApplicationId.cs               |  7 +-
 .../src/System/ArgumentException.cs           | 21 +++++
 .../src/System/Environment.cs                 | 13 +--
 .../System/Globalization/NumberFormatInfo.cs  | 39 ++------
 .../src/System/IO/Directory.cs                | 27 +-----
 .../src/System/IO/DirectoryInfo.cs            |  5 +-
 .../src/System/IO/File.cs                     | 44 ++-------
 .../src/System/IO/FileInfo.cs                 | 10 +-
 .../src/System/IO/FileStream.cs               | 16 +---
 .../src/System/IO/FileSystem.cs               | 11 +--
 .../src/System/IO/Path.Unix.cs                |  6 +-
 .../System/IO/Strategies/FileStreamHelpers.cs |  9 +-
 .../src/System/IO/StreamReader.cs             | 24 ++---
 .../src/System/IO/StreamWriter.cs             | 24 ++---
 .../Runtime/InteropServices/OSPlatform.cs     |  4 +-
 .../Runtime/Loader/AssemblyLoadContext.cs     | 10 +-
 .../Runtime/Versioning/FrameworkName.cs       | 26 +-----
 .../src/System/String.Manipulation.cs         | 19 +---
 .../src/System/Text/StringBuilder.cs          |  9 +-
 .../Threading/EventWaitHandle.Windows.cs      |  5 +-
 .../src/System/Threading/Mutex.Unix.cs        | 10 +-
 .../src/System/Threading/Mutex.Windows.cs     | 10 +-
 .../src/System/Threading/Semaphore.Windows.cs |  5 +-
 .../src/Resources/Strings.resx                |  6 +-
 .../src/System/Xml/Linq/XElement.cs           |  3 +-
 .../src/System/Xml/Linq/XName.cs              |  3 +-
 .../tests/SDMSample/SDMElement.cs             |  2 +-
 .../tests/SDMSample/SDMXName.cs               |  2 +-
 .../tests/Streaming/StreamingOutput.cs        |  2 +-
 .../tests/axes/InvalidParamValidation.cs      |  4 +-
 .../src/Resources/Strings.resx                |  3 -
 .../src/System/Xml/Core/XmlReader.cs          |  7 +-
 .../src/System/Xml/Core/XmlReaderSettings.cs  |  7 +-
 .../src/System/Xml/Core/XmlTextReaderImpl.cs  | 10 +-
 .../System.Reflection/tests/AssemblyTests.cs  |  2 +-
 .../System.Reflection/tests/GetTypeTests.cs   | 18 ++--
 .../System.Runtime/ref/System.Runtime.cs      |  1 +
 .../tests/System/ArgumentExceptionTests.cs    | 27 ++++++
 .../src/Resources/Strings.resx                | 15 ---
 .../Security/Cryptography/CngAlgorithm.cs     |  6 +-
 .../Cryptography/CngAlgorithmGroup.cs         |  6 +-
 .../Security/Cryptography/CngKeyBlobFormat.cs |  6 +-
 .../Security/Cryptography/CngProvider.cs      |  6 +-
 .../src/Resources/Strings.resx                |  3 -
 .../RSACryptoServiceProvider.Windows.cs       | 26 ++----
 .../src/Resources/Strings.resx                |  3 -
 .../src/Resources/Strings.resx                |  3 -
 .../X509Certificates/CertificateRequest.cs    | 51 ++++------
 .../CertificateRequestApiTests.cs             | 60 ++++++------
 .../src/System/Security/Cryptography/DSA.cs   | 90 ++++++------------
 .../src/System/Security/Cryptography/ECDsa.cs | 87 ++++++------------
 .../Security/Cryptography/IncrementalHash.cs  |  6 +-
 .../src/System/Security/Cryptography/RSA.cs   | 65 ++++---------
 .../Cryptography/RSAEncryptionPadding.cs      |  5 +-
 .../Rfc2898DeriveBytes.OneShot.cs             |  6 +-
 .../tests/DSATests.cs                         | 12 +--
 .../tests/ECDsaTests.cs                       | 12 +--
 .../tests/IncrementalHashTests.cs             |  4 +-
 .../tests/RSATests.cs                         |  6 +-
 .../tests/Rfc2898OneShotTests.cs              | 12 ++-
 .../src/Resources/Strings.resx                |  5 +-
 .../System/Security/Principal/NTAccount.cs    | 20 +---
 .../RegexCompilationInfo.cs                   | 11 +--
 .../Reflection/Emit/AssemblyBuilder.Mono.cs   | 21 +----
 .../Reflection/Emit/ModuleBuilder.Mono.cs     | 10 +-
 .../Reflection/Emit/TypeBuilder.Mono.cs       | 13 +--
 .../src/System/Reflection/RuntimeAssembly.cs  | 29 ++----
 .../src/System/Reflection/RuntimeModule.cs    |  5 +-
 136 files changed, 553 insertions(+), 1462 deletions(-)

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs
index 70cd4fb988f088..9def7541aa4c6a 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs
@@ -314,14 +314,7 @@ public ModuleBuilder DefineDynamicModule(string name)
 
         private ModuleBuilder DefineDynamicModuleInternalNoLock(string name)
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if (name[0] == '\0')
             {
                 throw new ArgumentException(SR.Argument_InvalidName, nameof(name));
@@ -467,14 +460,7 @@ public override Assembly GetSatelliteAssembly(CultureInfo culture, Version? vers
         /// <param name="name">The name of module for the look up.</param>
         private ModuleBuilder? GetDynamicModuleNoLock(string name)
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             for (int i = 0; i < _assemblyData._moduleBuilderList.Count; i++)
             {
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.cs
index e4c35c9dbbc034..c3e22c5d340719 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/FieldBuilder.cs
@@ -20,17 +20,12 @@ public sealed class FieldBuilder : FieldInfo
         internal FieldBuilder(TypeBuilder typeBuilder, string fieldName, Type type,
             Type[]? requiredCustomModifiers, Type[]? optionalCustomModifiers, FieldAttributes attributes)
         {
-            if (fieldName == null)
-                throw new ArgumentNullException(nameof(fieldName));
-
-            if (fieldName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(fieldName));
+            ArgumentException.ThrowIfNullOrEmpty(fieldName);
 
             if (fieldName[0] == '\0')
                 throw new ArgumentException(SR.Argument_IllegalName, nameof(fieldName));
 
-            if (type == null)
-                throw new ArgumentNullException(nameof(type));
+            ArgumentNullException.ThrowIfNull(type);
 
             if (type == typeof(void))
                 throw new ArgumentException(SR.Argument_BadFieldType);
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.cs
index 275cecbead57a6..1b35f5cdbb15f0 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.cs
@@ -1273,11 +1273,7 @@ public virtual void UsingNamespace(string usingNamespace)
             // Specifying the namespace to be used in evaluating locals and watches
             // for the current active lexical scope.
 
-            if (usingNamespace == null)
-                throw new ArgumentNullException(nameof(usingNamespace));
-
-            if (usingNamespace.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(usingNamespace));
+            ArgumentException.ThrowIfNullOrEmpty(usingNamespace);
 
             MethodBuilder? methodBuilder = m_methodBuilder as MethodBuilder;
             if (methodBuilder == null)
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/MethodBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/MethodBuilder.cs
index 176f5a3fd37296..9d11aacaf53ea8 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/MethodBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/MethodBuilder.cs
@@ -61,24 +61,18 @@ internal MethodBuilder(string name, MethodAttributes attributes, CallingConventi
             Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers,
             ModuleBuilder mod, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TypeBuilder type)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             if (name[0] == '\0')
                 throw new ArgumentException(SR.Argument_IllegalName, nameof(name));
 
-            if (mod == null)
-                throw new ArgumentNullException(nameof(mod));
+            ArgumentNullException.ThrowIfNull(mod);
 
             if (parameterTypes != null)
             {
                 foreach (Type t in parameterTypes)
                 {
-                    if (t == null)
-                        throw new ArgumentNullException(nameof(parameterTypes));
+                    ArgumentNullException.ThrowIfNull(t, nameof(parameterTypes));
                 }
             }
 
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
index f8b8c1efd35d03..cbe0a7b39dde5b 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
@@ -948,14 +948,7 @@ private MethodBuilder DefineGlobalMethodNoLock(string name, MethodAttributes att
             {
                 throw new InvalidOperationException(SR.InvalidOperation_GlobalsHaveBeenCreated);
             }
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if ((attributes & MethodAttributes.Static) == 0)
             {
                 throw new ArgumentException(SR.Argument_GlobalFunctionHasToBeStatic);
@@ -1352,18 +1345,8 @@ internal int GetArrayMethodToken(Type arrayClass, string methodName, CallingConv
         private int GetArrayMethodTokenNoLock(Type arrayClass, string methodName, CallingConventions callingConvention,
             Type? returnType, Type[]? parameterTypes)
         {
-            if (arrayClass == null)
-            {
-                throw new ArgumentNullException(nameof(arrayClass));
-            }
-            if (methodName == null)
-            {
-                throw new ArgumentNullException(nameof(methodName));
-            }
-            if (methodName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(methodName));
-            }
+            ArgumentNullException.ThrowIfNull(arrayClass);
+            ArgumentException.ThrowIfNullOrEmpty(methodName);
             if (!arrayClass.IsArray)
             {
                 throw new ArgumentException(SR.Argument_HasToBeArrayClass);
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/PropertyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/PropertyBuilder.cs
index ae6e704b2a5c87..89accc39caeb98 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/PropertyBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/PropertyBuilder.cs
@@ -34,10 +34,7 @@ internal PropertyBuilder(
             int prToken, // the metadata token for this property
             TypeBuilder containingType) // the containing type
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if (name[0] == '\0')
                 throw new ArgumentException(SR.Argument_IllegalName, nameof(name));
 
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
index a242ec948896be..ad80acad078350 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
@@ -480,11 +480,7 @@ internal TypeBuilder(
             string fullname, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, Type[]? interfaces, ModuleBuilder module,
             PackingSize iPackingSize, int iTypeSize, TypeBuilder? enclosingType)
         {
-            if (fullname == null)
-                throw new ArgumentNullException(nameof(fullname));
-
-            if (fullname.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(fullname));
+            ArgumentException.ThrowIfNullOrEmpty(fullname);
 
             if (fullname[0] == '\0')
                 throw new ArgumentException(SR.Argument_IllegalName, nameof(fullname));
@@ -581,11 +577,7 @@ private FieldBuilder DefineDataHelper(string name, byte[]? data, int size, Field
             FieldBuilder fdBuilder;
             TypeAttributes typeAttributes;
 
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             if (size <= 0 || size >= 0x003f0000)
                 throw new ArgumentException(SR.Argument_BadSizeForData);
@@ -1282,11 +1274,7 @@ private MethodBuilder DefineMethodNoLock(string name, MethodAttributes attribute
             Type? returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers,
             Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             AssemblyBuilder.CheckContext(returnType);
             AssemblyBuilder.CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
@@ -1374,23 +1362,9 @@ private MethodBuilder DefinePInvokeMethodHelper(
 
             lock (SyncRoot)
             {
-                if (name == null)
-                    throw new ArgumentNullException(nameof(name));
-
-                if (name.Length == 0)
-                    throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
-
-                if (dllName == null)
-                    throw new ArgumentNullException(nameof(dllName));
-
-                if (dllName.Length == 0)
-                    throw new ArgumentException(SR.Argument_EmptyName, nameof(dllName));
-
-                if (importName == null)
-                    throw new ArgumentNullException(nameof(importName));
-
-                if (importName.Length == 0)
-                    throw new ArgumentException(SR.Argument_EmptyName, nameof(importName));
+                ArgumentException.ThrowIfNullOrEmpty(name);
+                ArgumentException.ThrowIfNullOrEmpty(dllName);
+                ArgumentException.ThrowIfNullOrEmpty(importName);
 
                 if ((attributes & MethodAttributes.Abstract) != 0)
                     throw new ArgumentException(SR.Argument_BadPInvokeMethod);
@@ -1792,10 +1766,7 @@ private PropertyBuilder DefinePropertyNoLock(string name, PropertyAttributes att
             Type returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers,
             Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             AssemblyBuilder.CheckContext(returnType);
             AssemblyBuilder.CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
@@ -1847,10 +1818,7 @@ public EventBuilder DefineEvent(string name, EventAttributes attributes, Type ev
 
         private EventBuilder DefineEventNoLock(string name, EventAttributes attributes, Type eventtype)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if (name[0] == '\0')
                 throw new ArgumentException(SR.Argument_IllegalName, nameof(name));
 
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
index 32a37b6d4219f1..3708e71cb4510b 100644
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
@@ -558,8 +558,7 @@ private static partial void GetTypeByName(string name, bool throwOnError, bool i
 
         internal static RuntimeType GetTypeByNameUsingCARules(string name, RuntimeModule scope)
         {
-            if (string.IsNullOrEmpty(name))
-                throw new ArgumentException(null, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             RuntimeType? type = null;
             GetTypeByNameUsingCARules(name, new QCallModule(ref scope), ObjectHandleOnStack.Create(ref type));
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanAndroid.Derive.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanAndroid.Derive.cs
index a0b8af82113da7..dc902e555081bc 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanAndroid.Derive.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanAndroid.Derive.cs
@@ -23,10 +23,8 @@ public override byte[] DeriveKeyFromHash(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 ThrowIfDisposed();
 
@@ -45,10 +43,8 @@ public override byte[] DeriveKeyFromHmac(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 ThrowIfDisposed();
 
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanCng.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanCng.cs
index 90d2e4f01145c0..ad955d55ce8eed 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanCng.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanCng.cs
@@ -76,10 +76,8 @@ public override byte[] DeriveKeyFromHash(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 using (SafeNCryptSecretHandle secretAgreement = DeriveSecretAgreementHandle(otherPartyPublicKey))
                 {
@@ -99,10 +97,8 @@ public override byte[] DeriveKeyFromHmac(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 using (SafeNCryptSecretHandle secretAgreement = DeriveSecretAgreementHandle(otherPartyPublicKey))
                 {
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanOpenSsl.Derive.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanOpenSsl.Derive.cs
index 11638ed44be8a7..9d32a702bf07fa 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanOpenSsl.Derive.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanOpenSsl.Derive.cs
@@ -24,10 +24,8 @@ public override byte[] DeriveKeyFromHash(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 ThrowIfDisposed();
 
@@ -46,10 +44,8 @@ public override byte[] DeriveKeyFromHmac(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 ThrowIfDisposed();
 
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanSecurityTransforms.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanSecurityTransforms.cs
index 214bc96f8b0e95..df1a7fae8e39a0 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanSecurityTransforms.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanSecurityTransforms.cs
@@ -121,10 +121,8 @@ public override byte[] DeriveKeyFromHash(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 ThrowIfDisposed();
 
@@ -143,10 +141,8 @@ public override byte[] DeriveKeyFromHmac(
                 byte[]? secretPrepend,
                 byte[]? secretAppend)
             {
-                if (otherPartyPublicKey == null)
-                    throw new ArgumentNullException(nameof(otherPartyPublicKey));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
                 ThrowIfDisposed();
 
diff --git a/src/libraries/Common/src/System/Security/Cryptography/RSAAndroid.cs b/src/libraries/Common/src/System/Security/Cryptography/RSAAndroid.cs
index c78de735480356..86d98f5014f6cc 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/RSAAndroid.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/RSAAndroid.cs
@@ -678,12 +678,9 @@ protected override bool TryHashData(ReadOnlySpan<byte> data, Span<byte> destinat
 
             public override byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
             {
-                if (hash == null)
-                    throw new ArgumentNullException(nameof(hash));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw HashAlgorithmNameNullOrEmpty();
-                if (padding == null)
-                    throw new ArgumentNullException(nameof(padding));
+                ArgumentNullException.ThrowIfNull(hash);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(padding);
 
                 if (!TrySignHash(
                     hash,
@@ -708,14 +705,8 @@ public override bool TrySignHash(
                 RSASignaturePadding padding,
                 out int bytesWritten)
             {
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                {
-                    throw HashAlgorithmNameNullOrEmpty();
-                }
-                if (padding == null)
-                {
-                    throw new ArgumentNullException(nameof(padding));
-                }
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(padding);
 
                 bool ret = TrySignHash(
                     hash,
@@ -817,14 +808,8 @@ public override bool VerifyHash(
 
             public override bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
             {
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                {
-                    throw HashAlgorithmNameNullOrEmpty();
-                }
-                if (padding == null)
-                {
-                    throw new ArgumentNullException(nameof(padding));
-                }
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(padding);
                 if (padding != RSASignaturePadding.Pkcs1 && padding != RSASignaturePadding.Pss)
                 {
                     throw PaddingModeNotSupported();
@@ -894,9 +879,6 @@ public override bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> sign
 
             private static Exception PaddingModeNotSupported() =>
                 new CryptographicException(SR.Cryptography_InvalidPaddingMode);
-
-            private static Exception HashAlgorithmNameNullOrEmpty() =>
-                new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, "hashAlgorithm");
         }
     }
 }
diff --git a/src/libraries/Common/src/System/Security/Cryptography/RSACng.SignVerify.cs b/src/libraries/Common/src/System/Security/Cryptography/RSACng.SignVerify.cs
index 82709832cd88de..27fc35493783f6 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/RSACng.SignVerify.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/RSACng.SignVerify.cs
@@ -52,14 +52,9 @@ public override byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RS
             }
 
             string? hashAlgorithmName = hashAlgorithm.Name;
-            if (string.IsNullOrEmpty(hashAlgorithmName))
-            {
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
-            }
-            if (padding == null)
-            {
-                throw new ArgumentNullException(nameof(padding));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithmName, nameof(hashAlgorithm));
+
+            ArgumentNullException.ThrowIfNull(padding);
 
             if (hash.Length != GetHashSizeInBytes(hashAlgorithm))
             {
@@ -99,14 +94,8 @@ public override byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RS
         public override unsafe bool TrySignHash(ReadOnlySpan<byte> hash, Span<byte> destination, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding, out int bytesWritten)
         {
             string? hashAlgorithmName = hashAlgorithm.Name;
-            if (string.IsNullOrEmpty(hashAlgorithmName))
-            {
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
-            }
-            if (padding == null)
-            {
-                throw new ArgumentNullException(nameof(padding));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithmName, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             using (SafeNCryptKeyHandle keyHandle = GetDuplicatedKeyHandle())
             {
@@ -159,14 +148,8 @@ public override bool VerifyHash(byte[] hash, byte[] signature, HashAlgorithmName
         public override unsafe bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
         {
             string? hashAlgorithmName = hashAlgorithm.Name;
-            if (string.IsNullOrEmpty(hashAlgorithmName))
-            {
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
-            }
-            if (padding == null)
-            {
-                throw new ArgumentNullException(nameof(padding));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithmName, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             using (SafeNCryptKeyHandle keyHandle = GetDuplicatedKeyHandle())
             {
diff --git a/src/libraries/Common/src/System/Security/Cryptography/RSAOpenSsl.cs b/src/libraries/Common/src/System/Security/Cryptography/RSAOpenSsl.cs
index 149e240893039b..def40a8d5685a9 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/RSAOpenSsl.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/RSAOpenSsl.cs
@@ -750,12 +750,9 @@ protected override bool TryHashData(ReadOnlySpan<byte> data, Span<byte> destinat
 
         public override byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
         {
-            if (hash == null)
-                throw new ArgumentNullException(nameof(hash));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(hash);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             if (!TrySignHash(
                 hash,
@@ -780,14 +777,8 @@ public override bool TrySignHash(
             RSASignaturePadding padding,
             out int bytesWritten)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-            {
-                throw HashAlgorithmNameNullOrEmpty();
-            }
-            if (padding == null)
-            {
-                throw new ArgumentNullException(nameof(padding));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             bool ret = TrySignHash(
                 hash,
@@ -860,11 +851,7 @@ public override bool VerifyHash(
 
         public override bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-            {
-                throw HashAlgorithmNameNullOrEmpty();
-            }
-
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             ValidatePadding(padding);
 
             IntPtr digestAlgorithm = Interop.Crypto.HashAlgorithmToEvp(hashAlgorithm.Name);
@@ -951,9 +938,6 @@ private static void ValidatePadding(RSASignaturePadding padding)
 
         private static Exception PaddingModeNotSupported() =>
             new CryptographicException(SR.Cryptography_InvalidPaddingMode);
-
-        private static Exception HashAlgorithmNameNullOrEmpty() =>
-            new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, "hashAlgorithm");
     }
 #if INTERNAL_ASYMMETRIC_IMPLEMENTATIONS
     }
diff --git a/src/libraries/Common/src/System/Security/Cryptography/RSASecurityTransforms.cs b/src/libraries/Common/src/System/Security/Cryptography/RSASecurityTransforms.cs
index 7bce2648d443a9..190c7e4d53c9e2 100644
--- a/src/libraries/Common/src/System/Security/Cryptography/RSASecurityTransforms.cs
+++ b/src/libraries/Common/src/System/Security/Cryptography/RSASecurityTransforms.cs
@@ -386,12 +386,9 @@ private bool TryDecrypt(
 
             public override byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
             {
-                if (hash == null)
-                    throw new ArgumentNullException(nameof(hash));
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                    throw HashAlgorithmNameNullOrEmpty();
-                if (padding == null)
-                    throw new ArgumentNullException(nameof(padding));
+                ArgumentNullException.ThrowIfNull(hash);
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(padding);
 
                 ThrowIfDisposed();
 
@@ -443,14 +440,8 @@ public override byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RS
 
             public override bool TrySignHash(ReadOnlySpan<byte> hash, Span<byte> destination, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding, out int bytesWritten)
             {
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                {
-                    throw HashAlgorithmNameNullOrEmpty();
-                }
-                if (padding == null)
-                {
-                    throw new ArgumentNullException(nameof(padding));
-                }
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(padding);
 
                 ThrowIfDisposed();
 
@@ -550,14 +541,8 @@ public override bool VerifyHash(
 
             public override bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
             {
-                if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                {
-                    throw HashAlgorithmNameNullOrEmpty();
-                }
-                if (padding == null)
-                {
-                    throw new ArgumentNullException(nameof(padding));
-                }
+                ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+                ArgumentNullException.ThrowIfNull(padding);
 
                 ThrowIfDisposed();
 
@@ -795,8 +780,5 @@ private static bool HasConsistentPrivateKey(in RSAParameters parameters)
                 return true;
             }
         }
-
-        private static Exception HashAlgorithmNameNullOrEmpty() =>
-            new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, "hashAlgorithm");
     }
 }
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/DSA/DsaFamilySignatureFormatTests.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/DSA/DsaFamilySignatureFormatTests.cs
index b311193948a3a7..e214765dd47139 100644
--- a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/DSA/DsaFamilySignatureFormatTests.cs
+++ b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/DSA/DsaFamilySignatureFormatTests.cs
@@ -337,13 +337,21 @@ public void EmptyHashAlgorithm()
 
             foreach (DSASignatureFormat format in Enum.GetValues(typeof(DSASignatureFormat)))
             {
-                AssertExtensions.Throws<ArgumentException>(
+                AssertExtensions.Throws<ArgumentNullException>(
                     "hashAlgorithm",
                     () => SignData(key, empty, default, format));
 
-                AssertExtensions.Throws<ArgumentException>(
+                AssertExtensions.Throws<ArgumentNullException>(
                     "hashAlgorithm",
                     () => VerifyData(key, empty, empty, default, format));
+
+                AssertExtensions.Throws<ArgumentException>(
+                    "hashAlgorithm",
+                    () => SignData(key, empty, new HashAlgorithmName(""), format));
+
+                AssertExtensions.Throws<ArgumentException>(
+                    "hashAlgorithm",
+                    () => VerifyData(key, empty, empty, new HashAlgorithmName(""), format));
             }
         }
 
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.cs
index d747aec14e5517..187c76ad351a9f 100644
--- a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.cs
+++ b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.cs
@@ -40,9 +40,9 @@ public void SignData_InvalidArguments_Throws(ECDsa ecdsa)
             AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.SignData(new byte[0], 0, -1, default(HashAlgorithmName)));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.SignData(new byte[0], 0, 1, default(HashAlgorithmName)));
 
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new byte[0], default(HashAlgorithmName)));
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new byte[0], 0, 0, default(HashAlgorithmName)));
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new byte[0], 0, 0, default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.SignData(new byte[0], default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.SignData(new byte[0], 0, 0, default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.SignData(new byte[0], 0, 0, default(HashAlgorithmName)));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new byte[10], 0, 10, new HashAlgorithmName("")));
 
             Assert.ThrowsAny<CryptographicException>(() => ecdsa.SignData(new byte[0], new HashAlgorithmName(Guid.NewGuid().ToString("N"))));
@@ -64,8 +64,8 @@ public void VerifyData_InvalidArguments_Throws(ECDsa ecdsa)
             AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.VerifyData(new byte[0], 0, -1, null, default(HashAlgorithmName)));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.VerifyData(new byte[0], 0, 1, null, default(HashAlgorithmName)));
 
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[0], new byte[0], default(HashAlgorithmName)));
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[0], 0, 0, new byte[0], default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[0], new byte[0], default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[0], 0, 0, new byte[0], default(HashAlgorithmName)));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[10], new byte[0], new HashAlgorithmName("")));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[10], 0, 10, new byte[0], new HashAlgorithmName("")));
 
@@ -110,7 +110,8 @@ protected override byte[] SignData(ECDsa ecdsa, byte[] data, int offset, int cou
         public void SignData_InvalidArguments_Throws(ECDsa ecdsa)
         {
             AssertExtensions.Throws<ArgumentNullException>("data", () => ecdsa.SignData((Stream)null, default(HashAlgorithmName)));
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new MemoryStream(), default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.SignData(new MemoryStream(), default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new MemoryStream(), new HashAlgorithmName("")));
             Assert.ThrowsAny<CryptographicException>(() => ecdsa.SignData(new MemoryStream(), new HashAlgorithmName(Guid.NewGuid().ToString("N"))));
         }
 
@@ -119,7 +120,7 @@ public void VerifyData_InvalidArguments_Throws(ECDsa ecdsa)
         {
             AssertExtensions.Throws<ArgumentNullException>("data", () => ecdsa.VerifyData((Stream)null, null, default(HashAlgorithmName)));
             AssertExtensions.Throws<ArgumentNullException>("signature", () => ecdsa.VerifyData(new MemoryStream(), null, default(HashAlgorithmName)));
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new MemoryStream(), new byte[0], default(HashAlgorithmName)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.VerifyData(new MemoryStream(), new byte[0], default(HashAlgorithmName)));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new MemoryStream(), new byte[0], new HashAlgorithmName("")));
             Assert.ThrowsAny<CryptographicException>(() => ecdsa.VerifyData(new MemoryStream(), new byte[0], new HashAlgorithmName(Guid.NewGuid().ToString("N"))));
         }
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.netcoreapp.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.netcoreapp.cs
index eb12b87acba738..0f6a191e31dd0a 100644
--- a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.netcoreapp.cs
+++ b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDsa/ECDsaTests.netcoreapp.cs
@@ -28,7 +28,7 @@ protected override void UseAfterDispose(ECDsa ecdsa, byte[] data, byte[] sig)
         [Theory, MemberData(nameof(RealImplementations))]
         public void SignData_InvalidArguments_Throws(ECDsa ecdsa)
         {
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.TrySignData(ReadOnlySpan<byte>.Empty, Span<byte>.Empty, new HashAlgorithmName(null), out int bytesWritten));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.TrySignData(ReadOnlySpan<byte>.Empty, Span<byte>.Empty, new HashAlgorithmName(null), out int bytesWritten));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.TrySignData(ReadOnlySpan<byte>.Empty, Span<byte>.Empty, new HashAlgorithmName(""), out int bytesWritten));
             Assert.ThrowsAny<CryptographicException>(() => ecdsa.TrySignData(ReadOnlySpan<byte>.Empty, Span<byte>.Empty, new HashAlgorithmName(Guid.NewGuid().ToString("N")), out int bytesWritten));
         }
@@ -36,7 +36,7 @@ public void SignData_InvalidArguments_Throws(ECDsa ecdsa)
         [Theory, MemberData(nameof(RealImplementations))]
         public void VerifyData_InvalidArguments_Throws(ECDsa ecdsa)
         {
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(ReadOnlySpan<byte>.Empty, ReadOnlySpan<byte>.Empty, new HashAlgorithmName(null)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.VerifyData(ReadOnlySpan<byte>.Empty, ReadOnlySpan<byte>.Empty, new HashAlgorithmName(null)));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(ReadOnlySpan<byte>.Empty, ReadOnlySpan<byte>.Empty, new HashAlgorithmName("")));
             Assert.ThrowsAny<CryptographicException>(() => ecdsa.VerifyData(ReadOnlySpan<byte>.Empty, Span<byte>.Empty, new HashAlgorithmName(Guid.NewGuid().ToString("N"))));
         }
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/RSA/SignVerify.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/RSA/SignVerify.cs
index 4a7dace2695205..e78cea374bac53 100644
--- a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/RSA/SignVerify.cs
+++ b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/RSA/SignVerify.cs
@@ -48,14 +48,18 @@ public abstract class SignVerify
         protected abstract bool VerifyData(RSA rsa, byte[] data, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding);
         protected abstract bool VerifyHash(RSA rsa, byte[] hash, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding);
 
-        [Theory]
-        [InlineData(null)]
-        [InlineData("")]
-        public void InvalidHashAlgorithmName_Throws(string name)
+        [Fact]
+        public void InvalidHashAlgorithmName_Throws()
         {
             using (RSA rsa = RSAFactory.Create())
             {
-                var invalidName = new HashAlgorithmName(name);
+                var invalidName = new HashAlgorithmName(null);
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => SignData(rsa, new byte[1], invalidName, RSASignaturePadding.Pkcs1));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => SignHash(rsa, new byte[1], invalidName, RSASignaturePadding.Pkcs1));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => VerifyData(rsa, new byte[1], new byte[1], invalidName, RSASignaturePadding.Pkcs1));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => VerifyHash(rsa, new byte[1], new byte[1], invalidName, RSASignaturePadding.Pkcs1));
+
+                invalidName = new HashAlgorithmName("");
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => SignData(rsa, new byte[1], invalidName, RSASignaturePadding.Pkcs1));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => SignHash(rsa, new byte[1], invalidName, RSASignaturePadding.Pkcs1));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => VerifyData(rsa, new byte[1], new byte[1], invalidName, RSASignaturePadding.Pkcs1));
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx b/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx
index e9dd12b50616dd..f607a8a2fe91cd 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/Resources/Strings.resx
@@ -193,9 +193,6 @@
   <data name="MaskedTextProviderInvalidCharError" xml:space="preserve">
     <value>The specified character value is not allowed for this property.</value>
   </data>
-  <data name="MaskedTextProviderMaskNullOrEmpty" xml:space="preserve">
-    <value>The Mask value cannot be null or empty.</value>
-  </data>
   <data name="MaskedTextProviderMaskInvalidChar" xml:space="preserve">
     <value>The specified mask contains invalid characters.</value>
   </data>
@@ -253,4 +250,4 @@
   <data name="BinaryFormatterMessage" xml:space="preserve">
     <value>BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.</value>
   </data>
-</root>
\ No newline at end of file
+</root>
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/MaskedTextProvider.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/MaskedTextProvider.cs
index 16ebdaf6ab3008..5810df7258e5fc 100644
--- a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/MaskedTextProvider.cs
+++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/MaskedTextProvider.cs
@@ -227,10 +227,7 @@ public MaskedTextProvider(string mask, CultureInfo? culture, char passwordChar,
         /// </summary>
         public MaskedTextProvider(string mask, CultureInfo? culture, bool allowPromptAsInput, char promptChar, char passwordChar, bool restrictToAscii)
         {
-            if (string.IsNullOrEmpty(mask))
-            {
-                throw new ArgumentException(SR.MaskedTextProviderMaskNullOrEmpty, nameof(mask));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(mask);
 
             foreach (char c in mask)
             {
diff --git a/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx b/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx
index 2584ee5909a03f..ddbeed29f973ac 100644
--- a/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx
+++ b/src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx
@@ -215,9 +215,6 @@
   <data name="PendingAsyncOperation" xml:space="preserve">
     <value>An async read operation has already been started on the stream.</value>
   </data>
-  <data name="InvalidParameter" xml:space="preserve">
-    <value>Invalid value '{1}' for parameter '{0}'.</value>
-  </data>
   <data name="CategoryHelpCorrupt" xml:space="preserve">
     <value>Cannot load Category Help data because an invalid index '{0}' was read from the registry.</value>
   </data>
@@ -335,4 +332,4 @@
   <data name="InvalidSysctl" xml:space="preserve">
     <value>sysctl {0} failed with {1} error.</value>
   </data>
-</root>
\ No newline at end of file
+</root>
diff --git a/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.cs b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.cs
index 85525bbe3e8a59..7a776feba46dc6 100644
--- a/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.cs
+++ b/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.cs
@@ -10,11 +10,7 @@ internal static partial class ProcessManager
         /// <returns>true if the machine is remote; false if it's local.</returns>
         public static bool IsRemoteMachine(string machineName)
         {
-            if (machineName == null)
-                throw new ArgumentNullException(nameof(machineName));
-
-            if (machineName.Length == 0)
-                throw new ArgumentException(SR.Format(SR.InvalidParameter, nameof(machineName), machineName));
+            ArgumentException.ThrowIfNullOrEmpty(machineName);
 
             return IsRemoteMachineCore(machineName);
         }
diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs
index 18406af45353f4..b9d70837e3d168 100644
--- a/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs
+++ b/src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs
@@ -1147,7 +1147,7 @@ public void GetProcesseses_NullMachineName_ThrowsArgumentNullException()
         [Fact]
         public void GetProcesses_EmptyMachineName_ThrowsArgumentException()
         {
-            AssertExtensions.Throws<ArgumentException>(null, () => Process.GetProcesses(""));
+            AssertExtensions.Throws<ArgumentException>("machineName", () => Process.GetProcesses(""));
         }
 
         [Fact]
@@ -1292,7 +1292,7 @@ public void GetProcessesByName_NullMachineName_ThrowsArgumentNullException()
         public void GetProcessesByName_EmptyMachineName_ThrowsArgumentException()
         {
             Process currentProcess = Process.GetCurrentProcess();
-            AssertExtensions.Throws<ArgumentException>(null, () => Process.GetProcessesByName(currentProcess.ProcessName, ""));
+            AssertExtensions.Throws<ArgumentException>("machineName", () => Process.GetProcessesByName(currentProcess.ProcessName, ""));
         }
 
         [Fact]
diff --git a/src/libraries/System.Diagnostics.TextWriterTraceListener/src/Resources/Strings.resx b/src/libraries/System.Diagnostics.TextWriterTraceListener/src/Resources/Strings.resx
index 12b248f4ddec28..b994dce1b5ab60 100644
--- a/src/libraries/System.Diagnostics.TextWriterTraceListener/src/Resources/Strings.resx
+++ b/src/libraries/System.Diagnostics.TextWriterTraceListener/src/Resources/Strings.resx
@@ -1,4 +1,5 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -57,10 +58,7 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="Generic_ArgCantBeEmptyString" xml:space="preserve">
-    <value>'{0}' can not be empty string.</value>
-  </data>
   <data name="TraceAsTraceSource" xml:space="preserve">
     <value>Trace</value>
   </data>
-</root>
\ No newline at end of file
+</root>
diff --git a/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/DelimitedListTraceListener.cs b/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/DelimitedListTraceListener.cs
index 6c399ae77bc405..52454f94c69068 100644
--- a/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/DelimitedListTraceListener.cs
+++ b/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/DelimitedListTraceListener.cs
@@ -63,11 +63,7 @@ public string Delimiter
             }
             set
             {
-                if (value == null)
-                    throw new ArgumentNullException(nameof(Delimiter));
-
-                if (value.Length == 0)
-                    throw new ArgumentException(SR.Format(SR.Generic_ArgCantBeEmptyString, nameof(Delimiter)));
+                ArgumentException.ThrowIfNullOrEmpty(value, nameof(Delimiter));
 
                 lock (this)
                 {
diff --git a/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/CtorsDelimiterTests.cs b/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/CtorsDelimiterTests.cs
index f7620b442c5c19..352d0d1a6b29cb 100644
--- a/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/CtorsDelimiterTests.cs
+++ b/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/CtorsDelimiterTests.cs
@@ -90,8 +90,8 @@ public static void TestDelimiterProperty()
         {
             var target = new DelimitedListTraceListener(FileStream.Null);
             Assert.Equal(DefaultDelimiter, target.Delimiter);
-            Assert.Throws<ArgumentNullException>(() => target.Delimiter = null);
-            AssertExtensions.Throws<ArgumentException>(null, () => target.Delimiter = string.Empty);
+            AssertExtensions.Throws<ArgumentNullException>("Delimiter", () => target.Delimiter = null);
+            AssertExtensions.Throws<ArgumentException>("Delimiter", () => target.Delimiter = string.Empty);
         }
 
         [Fact]
diff --git a/src/libraries/System.Diagnostics.TraceSource/src/Resources/Strings.resx b/src/libraries/System.Diagnostics.TraceSource/src/Resources/Strings.resx
index 8b4f1d87314133..4062db3292bae6 100644
--- a/src/libraries/System.Diagnostics.TraceSource/src/Resources/Strings.resx
+++ b/src/libraries/System.Diagnostics.TraceSource/src/Resources/Strings.resx
@@ -1,4 +1,5 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -87,7 +88,4 @@
   <data name="TraceSwitchLevelTooHigh" xml:space="preserve">
     <value>Attempted to set {0} to a value that is too high.  Setting level to TraceLevel.Verbose</value>
   </data>
-  <data name="InvalidNullEmptyArgument" xml:space="preserve">
-    <value>Argument {0} cannot be null or zero-length.</value>
-  </data>
-</root>
\ No newline at end of file
+</root>
diff --git a/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/SwitchAttribute.cs b/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/SwitchAttribute.cs
index 4b474c82442af1..18b00fdf83f638 100644
--- a/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/SwitchAttribute.cs
+++ b/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/SwitchAttribute.cs
@@ -26,10 +26,7 @@ public string SwitchName
             [MemberNotNull(nameof(_name))]
             set
             {
-                if (value == null)
-                    throw new ArgumentNullException(nameof(value));
-                if (value.Length == 0)
-                    throw new ArgumentException(SR.Format(SR.InvalidNullEmptyArgument, nameof(value)), nameof(value));
+                ArgumentException.ThrowIfNullOrEmpty(value);
 
                 _name = value;
             }
diff --git a/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceSource.cs b/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceSource.cs
index aa786154cbb567..4aedca7d878f59 100644
--- a/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceSource.cs
+++ b/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceSource.cs
@@ -28,10 +28,7 @@ public TraceSource(string name)
 
         public TraceSource(string name, SourceLevels defaultLevel)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Format(SR.InvalidNullEmptyArgument, nameof(name)), nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             _sourceName = name;
             _switchLevel = defaultLevel;
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx b/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx
index 5b24a6296c36d0..60ea3e762eb475 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.FileSystem.AccessControl/src/Resources/Strings.resx
@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -188,13 +189,10 @@
   <data name="Argument_InvalidPathChars" xml:space="preserve">
     <value>Illegal characters in path '{0}'.</value>
   </data>
-  <data name="Arg_PathEmpty" xml:space="preserve">
-    <value>The path is empty.</value>
-  </data>
   <data name="ArgumentOutOfRange_NeedPosNum" xml:space="preserve">
     <value>Positive number required.</value>
   </data>
   <data name="Argument_InvalidFileModeAndFileSystemRightsCombo" xml:space="preserve">
     <value>Combining FileMode.{0} with FileSystemRights.{1} is invalid.</value>
   </data>
-</root>
+</root>
\ No newline at end of file
diff --git a/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs b/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs
index c47f9e255dc91c..0fc0de2a59b911 100644
--- a/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs
+++ b/src/libraries/System.IO.FileSystem.AccessControl/src/System/IO/FileSystemAclExtensions.cs
@@ -244,20 +244,8 @@ public static FileStream Create(this FileInfo fileInfo, FileMode mode, FileSyste
         /// <remarks>This extension method was added to .NET Core to bring the functionality that was provided by the `System.IO.Directory.CreateDirectory(System.String,System.Security.AccessControl.DirectorySecurity)` .NET Framework method.</remarks>
         public static DirectoryInfo CreateDirectory(this DirectorySecurity directorySecurity, string path)
         {
-            if (directorySecurity == null)
-            {
-                throw new ArgumentNullException(nameof(directorySecurity));
-            }
-
-            if (path == null)
-            {
-                throw new ArgumentNullException(nameof(path));
-            }
-
-            if (path.Length == 0)
-            {
-                throw new ArgumentException(SR.Arg_PathEmpty);
-            }
+            ArgumentNullException.ThrowIfNull(directorySecurity);
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             DirectoryInfo dirInfo = new DirectoryInfo(path);
 
diff --git a/src/libraries/System.IO.IsolatedStorage/src/Resources/Strings.resx b/src/libraries/System.IO.IsolatedStorage/src/Resources/Strings.resx
index 7575c8e979de03..4a82720401dc57 100644
--- a/src/libraries/System.IO.IsolatedStorage/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.IsolatedStorage/src/Resources/Strings.resx
@@ -1,4 +1,5 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -93,9 +94,6 @@
   <data name="IsolatedStorage_NotValidOnDesktop" xml:space="preserve">
     <value>The Site scope is currently not supported.</value>
   </data>
-  <data name="Argument_EmptyPath" xml:space="preserve">
-    <value>Empty path name is not legal.</value>
-  </data>
   <data name="ArgumentOutOfRange_NeedNonNegNum" xml:space="preserve">
     <value>Non-negative number required.</value>
   </data>
diff --git a/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorageFile.cs b/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorageFile.cs
index b79b1a81716266..bb6360f00d5b84 100644
--- a/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorageFile.cs
+++ b/src/libraries/System.IO.IsolatedStorage/src/System/IO/IsolatedStorage/IsolatedStorageFile.cs
@@ -288,13 +288,7 @@ public IsolatedStorageFileStream CreateFile(string path)
 
         public DateTimeOffset GetCreationTime(string path)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-
-            if (path.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             EnsureStoreIsValid();
 
@@ -310,13 +304,7 @@ public DateTimeOffset GetCreationTime(string path)
 
         public DateTimeOffset GetLastAccessTime(string path)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-
-            if (path.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             EnsureStoreIsValid();
 
@@ -332,13 +320,7 @@ public DateTimeOffset GetLastAccessTime(string path)
 
         public DateTimeOffset GetLastWriteTime(string path)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-
-            if (path.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             EnsureStoreIsValid();
 
@@ -354,42 +336,16 @@ public DateTimeOffset GetLastWriteTime(string path)
 
         public void CopyFile(string sourceFileName, string destinationFileName)
         {
-            if (sourceFileName == null)
-                throw new ArgumentNullException(nameof(sourceFileName));
-
-            if (destinationFileName == null)
-                throw new ArgumentNullException(nameof(destinationFileName));
-
-            if (sourceFileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(sourceFileName));
-            }
-
-            if (destinationFileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(destinationFileName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(sourceFileName);
+            ArgumentException.ThrowIfNullOrEmpty(destinationFileName);
 
             CopyFile(sourceFileName, destinationFileName, false);
         }
 
         public void CopyFile(string sourceFileName, string destinationFileName, bool overwrite)
         {
-            if (sourceFileName == null)
-                throw new ArgumentNullException(nameof(sourceFileName));
-
-            if (destinationFileName == null)
-                throw new ArgumentNullException(nameof(destinationFileName));
-
-            if (sourceFileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(sourceFileName));
-            }
-
-            if (destinationFileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(destinationFileName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(sourceFileName);
+            ArgumentException.ThrowIfNullOrEmpty(destinationFileName);
 
             EnsureStoreIsValid();
 
@@ -416,21 +372,8 @@ public void CopyFile(string sourceFileName, string destinationFileName, bool ove
 
         public void MoveFile(string sourceFileName, string destinationFileName)
         {
-            if (sourceFileName == null)
-                throw new ArgumentNullException(nameof(sourceFileName));
-
-            if (destinationFileName == null)
-                throw new ArgumentNullException(nameof(destinationFileName));
-
-            if (sourceFileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(sourceFileName));
-            }
-
-            if (destinationFileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(destinationFileName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(sourceFileName);
+            ArgumentException.ThrowIfNullOrEmpty(destinationFileName);
 
             EnsureStoreIsValid();
 
@@ -457,21 +400,8 @@ public void MoveFile(string sourceFileName, string destinationFileName)
 
         public void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName)
         {
-            if (sourceDirectoryName == null)
-                throw new ArgumentNullException(nameof(sourceDirectoryName));
-
-            if (destinationDirectoryName == null)
-                throw new ArgumentNullException(nameof(destinationDirectoryName));
-
-            if (sourceDirectoryName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(sourceDirectoryName));
-            }
-
-            if (destinationDirectoryName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(destinationDirectoryName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(sourceDirectoryName);
+            ArgumentException.ThrowIfNullOrEmpty(destinationDirectoryName);
 
             EnsureStoreIsValid();
 
diff --git a/src/libraries/System.IO.MemoryMappedFiles/src/Resources/Strings.resx b/src/libraries/System.IO.MemoryMappedFiles/src/Resources/Strings.resx
index 64fde1d7fe266e..bdfb97a73c8020 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.MemoryMappedFiles/src/Resources/Strings.resx
@@ -1,4 +1,5 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
   <!-- 
     Microsoft ResX Schema 
     
@@ -170,9 +171,6 @@
   <data name="Argument_NewMMFTruncateModeNotAllowed" xml:space="preserve">
     <value>FileMode.Truncate is not permitted when creating new memory mapped files.</value>
   </data>
-  <data name="ArgumentNull_MapName" xml:space="preserve">
-    <value>Map name cannot be null.</value>
-  </data>
   <data name="ArgumentNull_FileStream" xml:space="preserve">
     <value>fileStream cannot be null.</value>
   </data>
@@ -221,4 +219,4 @@
   <data name="IO_PathTooLong_Path" xml:space="preserve">
     <value>The path '{0}' is too long, or a component of the specified path is too long.</value>
   </data>
-</root>
+</root>
\ No newline at end of file
diff --git a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.cs b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.cs
index cc8d30ca73ef19..7565b5d678456d 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.cs
@@ -60,15 +60,7 @@ public static MemoryMappedFile OpenExisting(string mapName, MemoryMappedFileRigh
         public static MemoryMappedFile OpenExisting(string mapName, MemoryMappedFileRights desiredAccessRights,
                                                                     HandleInheritability inheritability)
         {
-            if (mapName == null)
-            {
-                throw new ArgumentNullException(nameof(mapName), SR.ArgumentNull_MapName);
-            }
-
-            if (mapName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_MapNameEmptyString);
-            }
+            ArgumentException.ThrowIfNullOrEmpty(mapName);
 
             if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable)
             {
@@ -319,15 +311,7 @@ public static MemoryMappedFile CreateOrOpen(string mapName, long capacity,
                                                     MemoryMappedFileAccess access, MemoryMappedFileOptions options,
                                                     HandleInheritability inheritability)
         {
-            if (mapName == null)
-            {
-                throw new ArgumentNullException(nameof(mapName), SR.ArgumentNull_MapName);
-            }
-
-            if (mapName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_MapNameEmptyString);
-            }
+            ArgumentException.ThrowIfNullOrEmpty(mapName);
 
             if (capacity <= 0)
             {
diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs
index 216c96d86b28a0..86d27f4a52c9bd 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs
@@ -20,9 +20,9 @@ public void InvalidArguments_MapName()
             AssertExtensions.Throws<ArgumentNullException>("mapName", () => MemoryMappedFile.CreateOrOpen(null, 4096, MemoryMappedFileAccess.ReadWrite, MemoryMappedFileOptions.None, HandleInheritability.None));
 
             // Empty string is always an invalid map name
-            AssertExtensions.Throws<ArgumentException>(null, () => MemoryMappedFile.CreateOrOpen(string.Empty, 4096));
-            AssertExtensions.Throws<ArgumentException>(null, () => MemoryMappedFile.CreateOrOpen(string.Empty, 4096, MemoryMappedFileAccess.ReadWrite));
-            AssertExtensions.Throws<ArgumentException>(null, () => MemoryMappedFile.CreateOrOpen(string.Empty, 4096, MemoryMappedFileAccess.ReadWrite, MemoryMappedFileOptions.None, HandleInheritability.None));
+            AssertExtensions.Throws<ArgumentException>("mapName", () => MemoryMappedFile.CreateOrOpen(string.Empty, 4096));
+            AssertExtensions.Throws<ArgumentException>("mapName", () => MemoryMappedFile.CreateOrOpen(string.Empty, 4096, MemoryMappedFileAccess.ReadWrite));
+            AssertExtensions.Throws<ArgumentException>("mapName", () => MemoryMappedFile.CreateOrOpen(string.Empty, 4096, MemoryMappedFileAccess.ReadWrite, MemoryMappedFileOptions.None, HandleInheritability.None));
         }
 
         /// <summary>
diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.OpenExisting.Tests.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.OpenExisting.Tests.cs
index ddd2aae6e19184..cfb2a9c507aa16 100644
--- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.OpenExisting.Tests.cs
+++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.OpenExisting.Tests.cs
@@ -18,7 +18,7 @@ public void InvalidArguments_Name()
             AssertExtensions.Throws<ArgumentNullException>("mapName", () => MemoryMappedFile.OpenExisting(null));
 
             // Empty is never a valid map name
-            AssertExtensions.Throws<ArgumentException>(null, () => MemoryMappedFile.OpenExisting(string.Empty));
+            AssertExtensions.Throws<ArgumentException>("mapName", () => MemoryMappedFile.OpenExisting(string.Empty));
         }
 
         /// <summary>
diff --git a/src/libraries/System.IO.Pipes/src/Resources/Strings.resx b/src/libraries/System.IO.Pipes/src/Resources/Strings.resx
index 3300dc0181fb0b..166aacdb95798c 100644
--- a/src/libraries/System.IO.Pipes/src/Resources/Strings.resx
+++ b/src/libraries/System.IO.Pipes/src/Resources/Strings.resx
@@ -123,9 +123,6 @@
   <data name="ArgumentOutOfRange_NeedValidPipeAccessRights" xml:space="preserve">
     <value>Invalid PipeAccessRights value.</value>
   </data>
-  <data name="Argument_NeedNonemptyPipeName" xml:space="preserve">
-    <value>pipeName cannot be an empty string.</value>
-  </data>
   <data name="Argument_NonContainerInvalidAnyFlag" xml:space="preserve">
     <value>This flag may not be set on a pipe.</value>
   </data>
diff --git a/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.cs b/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.cs
index a03b5f1eaa524a..a0240686342174 100644
--- a/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.cs
+++ b/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.cs
@@ -56,18 +56,8 @@ public NamedPipeClientStream(string serverName, string pipeName, PipeDirection d
             PipeOptions options, TokenImpersonationLevel impersonationLevel, HandleInheritability inheritability)
             : base(direction, 0)
         {
-            if (pipeName == null)
-            {
-                throw new ArgumentNullException(nameof(pipeName));
-            }
-            if (serverName == null)
-            {
-                throw new ArgumentNullException(nameof(serverName), SR.ArgumentNull_ServerName);
-            }
-            if (pipeName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_NeedNonemptyPipeName);
-            }
+            ArgumentException.ThrowIfNullOrEmpty(pipeName);
+            ArgumentNullException.ThrowIfNull(serverName);
             if (serverName.Length == 0)
             {
                 throw new ArgumentException(SR.Argument_EmptyServerName);
diff --git a/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs b/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs
index 596f3504c49f7d..9fc1106e29282d 100644
--- a/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs
+++ b/src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs
@@ -94,14 +94,7 @@ private void ValidateParameters(
             int outBufferSize,
             HandleInheritability inheritability)
         {
-            if (pipeName == null)
-            {
-                throw new ArgumentNullException(nameof(pipeName));
-            }
-            if (pipeName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_NeedNonemptyPipeName);
-            }
+            ArgumentException.ThrowIfNullOrEmpty(pipeName);
             if (direction < PipeDirection.In || direction > PipeDirection.InOut)
             {
                 throw new ArgumentOutOfRangeException(nameof(direction), SR.ArgumentOutOfRange_DirectionModeInOutOrInOut);
diff --git a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs
index 35fac2a2ddbf42..9ebef55d8909ea 100644
--- a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs
+++ b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs
@@ -22,8 +22,8 @@ public static void NullPipeName_Throws_ArgumentNullException()
         [Fact]
         public static void EmptyStringPipeName_Throws_ArgumentException()
         {
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeClientStream(""));
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeClientStream(".", ""));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeClientStream(""));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeClientStream(".", ""));
         }
 
         [Theory]
diff --git a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateServer.cs b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateServer.cs
index 10a97116eb7da0..f60509373c2f47 100644
--- a/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateServer.cs
+++ b/src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateServer.cs
@@ -31,12 +31,12 @@ public static void NullPipeName_Throws_ArgumentNullException(PipeDirection direc
         [InlineData(PipeDirection.Out)]
         public static void ZeroLengthPipeName_Throws_ArgumentException(PipeDirection direction)
         {
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeServerStream(""));
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeServerStream("", direction));
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeServerStream("", direction, 2));
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte));
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte, PipeOptions.None));
-            AssertExtensions.Throws<ArgumentException>(null, () => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte, PipeOptions.None, 0, 0));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeServerStream(""));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeServerStream("", direction));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeServerStream("", direction, 2));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte, PipeOptions.None));
+            AssertExtensions.Throws<ArgumentException>("pipeName", () => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte, PipeOptions.None, 0, 0));
         }
 
         [Theory]
diff --git a/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs b/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs
index 2e19dd283ebbb1..b96ed8532d383c 100644
--- a/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs
+++ b/src/libraries/System.IO/tests/StreamReader/StreamReader.StringCtorTests.cs
@@ -19,10 +19,10 @@ public static void NullArgs_ThrowsArgumentNullException()
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamReader((string)null, null, true));
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamReader((string)null, null, true, null));
             AssertExtensions.Throws<ArgumentNullException>("path", () => new StreamReader((string)null, null, true, -1));
-            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("", (Encoding)null));
-            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("", null, true));
-            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("", null, true, null));
-            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("", null, true, -1));
+            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("path", (Encoding)null));
+            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("path", null, true));
+            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("path", null, true, null));
+            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamReader("path", null, true, -1));
             AssertExtensions.Throws<ArgumentNullException>("options", () => new StreamReader("path", (FileStreamOptions)null));
             AssertExtensions.Throws<ArgumentNullException>("options", () => new StreamReader("path", Encoding.UTF8, true, null));
 
@@ -32,12 +32,12 @@ public static void NullArgs_ThrowsArgumentNullException()
         public static void EmptyPath_ThrowsArgumentException()
         {
             // No argument name for the empty path exception
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamReader(""));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamReader("", new FileStreamOptions()));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamReader("", Encoding.UTF8));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamReader("", Encoding.UTF8, true));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamReader("", Encoding.UTF8, true, new FileStreamOptions()));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamReader("", Encoding.UTF8, true, -1));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamReader(""));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamReader("", new FileStreamOptions()));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamReader("", Encoding.UTF8));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamReader("", Encoding.UTF8, true));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamReader("", Encoding.UTF8, true, new FileStreamOptions()));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamReader("", Encoding.UTF8, true, -1));
         }
 
         [Fact]
diff --git a/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs b/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs
index 841ff591aeff23..6900fb973843b9 100644
--- a/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs
+++ b/src/libraries/System.IO/tests/StreamWriter/StreamWriter.StringCtorTests.cs
@@ -22,21 +22,18 @@ public static void NullArgs_ThrowsArgumentNullException()
             AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamWriter("path", true, null));
             AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamWriter("path", null, null));
             AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamWriter("path", true, null, -1));
-            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamWriter("", true, null));
-            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamWriter("", null, null));
-            AssertExtensions.Throws<ArgumentNullException>("encoding", () => new StreamWriter("", true, null, -1));
         }
 
         [Fact]
         public static void EmptyPath_ThrowsArgumentException()
         {
             // No argument name for the empty path exception
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamWriter(""));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamWriter("", new FileStreamOptions()));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamWriter("", true));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamWriter("", true, Encoding.UTF8));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamWriter("", Encoding.UTF8, new FileStreamOptions()));
-            AssertExtensions.Throws<ArgumentException>(null, () => new StreamWriter("", true, Encoding.UTF8, -1));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamWriter(""));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamWriter("", new FileStreamOptions()));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamWriter("", true));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamWriter("", true, Encoding.UTF8));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamWriter("", Encoding.UTF8, new FileStreamOptions()));
+            AssertExtensions.Throws<ArgumentException>("path", () => new StreamWriter("", true, Encoding.UTF8, -1));
         }
 
         [Fact]
diff --git a/src/libraries/System.Net.Mail/src/Resources/Strings.resx b/src/libraries/System.Net.Mail/src/Resources/Strings.resx
index a72e327927cce5..06521daf4ca9d5 100644
--- a/src/libraries/System.Net.Mail/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Mail/src/Resources/Strings.resx
@@ -1,4 +1,5 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -57,19 +58,12 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-
-  <data name="net_emptystringcall" xml:space="preserve">
-    <value>The parameter '{0}' cannot be an empty string.</value>
-  </data>
   <data name="net_io_invalidasyncresult" xml:space="preserve">
     <value>The IAsyncResult object was not returned from the corresponding asynchronous method on this class.</value>
   </data>
   <data name="net_io_invalidendcall" xml:space="preserve">
     <value>{0} can only be called once for each asynchronous operation.</value>
   </data>
-  <data name="net_emptystringset" xml:space="preserve">
-    <value>This property cannot be set to an empty string.</value>
-  </data>
   <data name="net_MethodNotImplementedException" xml:space="preserve">
     <value>This method is not implemented by this class.</value>
   </data>
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mail/Attachment.cs b/src/libraries/System.Net.Mail/src/System/Net/Mail/Attachment.cs
index aaca28f6a4c8cb..4fc0954e945210 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mail/Attachment.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mail/Attachment.cs
@@ -68,15 +68,7 @@ protected virtual void Dispose(bool disposing)
 
         internal void SetContentFromFile(string fileName, ContentType? contentType)
         {
-            if (fileName == null)
-            {
-                throw new ArgumentNullException(nameof(fileName));
-            }
-
-            if (fileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(fileName)), nameof(fileName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(fileName);
 
             Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
             _part.SetContent(stream, contentType);
@@ -84,15 +76,7 @@ internal void SetContentFromFile(string fileName, ContentType? contentType)
 
         internal void SetContentFromFile(string fileName, string? mediaType)
         {
-            if (fileName == null)
-            {
-                throw new ArgumentNullException(nameof(fileName));
-            }
-
-            if (fileName.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(fileName)), nameof(fileName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(fileName);
 
             Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
             _part.SetContent(stream, null, mediaType);
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddress.cs b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddress.cs
index 1acfc449c5afdb..ae8940ef25f926 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddress.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddress.cs
@@ -119,15 +119,12 @@ public static bool TryCreate(string address, string? displayName, Encoding? disp
 
         private static bool TryParse(string address, string? displayName, Encoding? displayNameEncoding, out (string displayName, string user, string host, Encoding displayNameEncoding) parsedData, bool throwExceptionIfFail)
         {
-            if (string.IsNullOrEmpty(address))
+            if (throwExceptionIfFail)
+            {
+                ArgumentException.ThrowIfNullOrEmpty(address);
+            }
+            else if (string.IsNullOrEmpty(address))
             {
-                if (throwExceptionIfFail)
-                {
-                    throw address is null ?
-                        new ArgumentNullException(nameof(address)) :
-                        new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(address)), nameof(address));
-                }
-
                 parsedData = default;
                 return false;
             }
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddressCollection.cs b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddressCollection.cs
index 88bea09486e767..41d3ba32a70219 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddressCollection.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailAddressCollection.cs
@@ -18,14 +18,7 @@ public MailAddressCollection()
 
         public void Add(string addresses)
         {
-            if (addresses == null)
-            {
-                throw new ArgumentNullException(nameof(addresses));
-            }
-            if (addresses.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(addresses)), nameof(addresses));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(addresses);
 
             ParseValue(addresses);
         }
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailMessage.cs b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailMessage.cs
index 4e7ad597cabf9c..dfa63b9641f7ca 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailMessage.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailMessage.cs
@@ -37,17 +37,8 @@ public MailMessage()
 
         public MailMessage(string from, string to)
         {
-            if (from == null)
-                throw new ArgumentNullException(nameof(from));
-
-            if (to == null)
-                throw new ArgumentNullException(nameof(to));
-
-            if (from.Length == 0)
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(from)), nameof(from));
-
-            if (to.Length == 0)
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(to)), nameof(to));
+            ArgumentException.ThrowIfNullOrEmpty(from);
+            ArgumentException.ThrowIfNullOrEmpty(to);
 
             _message = new Message(from, to);
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Associate(this, _message);
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailPriority.cs b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailPriority.cs
index 53e41d8f86e6c1..e6536a48e2b456 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mail/MailPriority.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mail/MailPriority.cs
@@ -44,17 +44,8 @@ internal Message()
 
         internal Message(string from, string to) : this()
         {
-            if (from == null)
-                throw new ArgumentNullException(nameof(from));
-
-            if (to == null)
-                throw new ArgumentNullException(nameof(to));
-
-            if (from.Length == 0)
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(from)), nameof(from));
-
-            if (to.Length == 0)
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(to)), nameof(to));
+            ArgumentException.ThrowIfNullOrEmpty(from);
+            ArgumentException.ThrowIfNullOrEmpty(to);
 
             _from = new MailAddress(from);
             MailAddressCollection collection = new MailAddressCollection();
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mail/SmtpClient.cs b/src/libraries/System.Net.Mail/src/System/Net/Mail/SmtpClient.cs
index beeea14766bca5..71f0af271d14b2 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mail/SmtpClient.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mail/SmtpClient.cs
@@ -168,15 +168,7 @@ public string? Host
                     throw new InvalidOperationException(SR.SmtpInvalidOperationDuringSend);
                 }
 
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-
-                if (value.Length == 0)
-                {
-                    throw new ArgumentException(SR.net_emptystringset, nameof(value));
-                }
+                ArgumentException.ThrowIfNullOrEmpty(value);
 
                 value = value.Trim();
 
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentDisposition.cs b/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentDisposition.cs
index b3ca5f87ac5090..028e9456ce3d1e 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentDisposition.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentDisposition.cs
@@ -79,14 +79,7 @@ public string DispositionType
             get { return _dispositionType; }
             set
             {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-                if (value.Length == 0)
-                {
-                    throw new ArgumentException(SR.net_emptystringset, nameof(value));
-                }
+                ArgumentException.ThrowIfNullOrEmpty(value);
 
                 _isChanged = true;
                 _dispositionType = value;
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentType.cs b/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentType.cs
index 5595f7aab22288..08bcb5e7c6e729 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentType.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mime/ContentType.cs
@@ -45,14 +45,7 @@ public ContentType() : this(Default)
         /// <param name="contentType">Unparsed value of the Content-Type header.</param>
         public ContentType(string contentType)
         {
-            if (contentType == null)
-            {
-                throw new ArgumentNullException(nameof(contentType));
-            }
-            if (contentType.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(contentType)), nameof(contentType));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(contentType);
 
             _isChanged = true;
             _type = contentType;
@@ -99,15 +92,7 @@ public string MediaType
             get { return _mediaType + "/" + _subType; }
             set
             {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-
-                if (value.Length == 0)
-                {
-                    throw new ArgumentException(SR.net_emptystringset, nameof(value));
-                }
+                ArgumentException.ThrowIfNullOrEmpty(value);
 
                 int offset = 0;
                 _mediaType = MailBnfHelper.ReadToken(value, ref offset, null);
diff --git a/src/libraries/System.Net.Mail/src/System/Net/Mime/HeaderCollection.cs b/src/libraries/System.Net.Mail/src/System/Net/Mime/HeaderCollection.cs
index 89f988930f6ef7..c77b6abdbaac44 100644
--- a/src/libraries/System.Net.Mail/src/System/Net/Mime/HeaderCollection.cs
+++ b/src/libraries/System.Net.Mail/src/System/Net/Mime/HeaderCollection.cs
@@ -22,15 +22,7 @@ internal HeaderCollection() : base(StringComparer.OrdinalIgnoreCase)
         public override void Remove(string name)
 #pragma warning restore CS8765
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(name)), nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             base.Remove(name);
         }
@@ -40,15 +32,7 @@ public override void Remove(string name)
         public override string? Get(string name)
 #pragma warning restore CS8765
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(name)), nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             return base.Get(name);
         }
@@ -57,15 +41,7 @@ public override void Remove(string name)
         public override string[]? GetValues(string name)
 #pragma warning restore CS8765
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(name)), nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             return base.GetValues(name);
         }
@@ -93,25 +69,8 @@ internal void InternalAdd(string name, string value)
         public override void Set(string name, string value)
 #pragma warning restore CS8765
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (value == null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(name)), nameof(name));
-            }
-
-            if (value.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(value)), nameof(value));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
+            ArgumentException.ThrowIfNullOrEmpty(value);
 
             if (!MimeBasePart.IsAscii(name, false))
             {
@@ -131,22 +90,8 @@ public override void Set(string name, string value)
         public override void Add(string name, string value)
 #pragma warning restore CS8765
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-            if (value == null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(name)), nameof(name));
-            }
-            if (value.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(value)), nameof(value));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
+            ArgumentException.ThrowIfNullOrEmpty(value);
 
             MailBnfHelper.ValidateHeaderName(name);
 
diff --git a/src/libraries/System.Net.Primitives/src/System/Net/CredentialCache.cs b/src/libraries/System.Net.Primitives/src/System/Net/CredentialCache.cs
index f0e19c005ab7fb..d12a7b9d0751b3 100644
--- a/src/libraries/System.Net.Primitives/src/System/Net/CredentialCache.cs
+++ b/src/libraries/System.Net.Primitives/src/System/Net/CredentialCache.cs
@@ -57,20 +57,8 @@ public void Add(Uri uriPrefix, string authType, NetworkCredential cred)
 
         public void Add(string host, int port, string authenticationType, NetworkCredential credential)
         {
-            if (host == null)
-            {
-                throw new ArgumentNullException(nameof(host));
-            }
-
-            if (authenticationType == null)
-            {
-                throw new ArgumentNullException(nameof(authenticationType));
-            }
-
-            if (host.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(host)), nameof(host));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(host);
+            ArgumentNullException.ThrowIfNull(authenticationType);
 
             if (port < 0)
             {
@@ -200,18 +188,8 @@ public void Remove(string? host, int port, string? authenticationType)
 
         public NetworkCredential? GetCredential(string host, int port, string authenticationType)
         {
-            if (host == null)
-            {
-                throw new ArgumentNullException(nameof(host));
-            }
-            if (authenticationType == null)
-            {
-                throw new ArgumentNullException(nameof(authenticationType));
-            }
-            if (host.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(host)), nameof(host));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(host);
+            ArgumentNullException.ThrowIfNull(authenticationType);
             if (port < 0)
             {
                 throw new ArgumentOutOfRangeException(nameof(port));
diff --git a/src/libraries/System.Net.Primitives/src/System/Net/DnsEndPoint.cs b/src/libraries/System.Net.Primitives/src/System/Net/DnsEndPoint.cs
index fc6fb3b9177bbc..1cdc3c5774cc7f 100644
--- a/src/libraries/System.Net.Primitives/src/System/Net/DnsEndPoint.cs
+++ b/src/libraries/System.Net.Primitives/src/System/Net/DnsEndPoint.cs
@@ -16,15 +16,7 @@ public DnsEndPoint(string host, int port) : this(host, port, AddressFamily.Unspe
 
         public DnsEndPoint(string host, int port, AddressFamily addressFamily)
         {
-            if (host == null)
-            {
-                throw new ArgumentNullException(nameof(host));
-            }
-
-            if (string.IsNullOrEmpty(host))
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptystringcall, nameof(host)));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(host);
 
             if (port < IPEndPoint.MinPort || port > IPEndPoint.MaxPort)
             {
diff --git a/src/libraries/System.Net.Primitives/tests/FunctionalTests/DnsEndPointTest.cs b/src/libraries/System.Net.Primitives/tests/FunctionalTests/DnsEndPointTest.cs
index b43ac159ead52e..4d826d0e61afa2 100644
--- a/src/libraries/System.Net.Primitives/tests/FunctionalTests/DnsEndPointTest.cs
+++ b/src/libraries/System.Net.Primitives/tests/FunctionalTests/DnsEndPointTest.cs
@@ -30,8 +30,8 @@ public static void Ctor_HostPort_AddressFamily_Success()
         [Fact]
         public static void Ctor_HostPortAddressFamily_Invalid()
         {
-            Assert.Throws<ArgumentNullException>(() => new DnsEndPoint(null, 500, AddressFamily.InterNetwork)); //Null host
-            AssertExtensions.Throws<ArgumentException>(null, () => new DnsEndPoint("", 500, AddressFamily.InterNetwork)); //Empty host
+            AssertExtensions.Throws<ArgumentNullException>("host", () => new DnsEndPoint(null, 500, AddressFamily.InterNetwork)); //Null host
+            AssertExtensions.Throws<ArgumentException>("host", () => new DnsEndPoint("", 500, AddressFamily.InterNetwork)); //Empty host
 
             Assert.Throws<ArgumentOutOfRangeException>(() => new DnsEndPoint("host", IPEndPoint.MinPort - 1, AddressFamily.InterNetwork)); //Port < min port (0)
             Assert.Throws<ArgumentOutOfRangeException>(() => new DnsEndPoint("host", IPEndPoint.MaxPort + 1, AddressFamily.InterNetwork)); //Port > max port (65535)
diff --git a/src/libraries/System.Net.Security/src/Resources/Strings.resx b/src/libraries/System.Net.Security/src/Resources/Strings.resx
index d85383c3e906bc..5373ba6ee33071 100644
--- a/src/libraries/System.Net.Security/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.Security/src/Resources/Strings.resx
@@ -266,9 +266,6 @@
   <data name="security_ExtendedProtectionPolicy_NoEmptyServiceNameCollection" xml:space="preserve">
     <value>The ServiceNameCollection must contain at least one service name.</value>
   </data>
-  <data name="security_ServiceNameCollection_EmptyServiceName" xml:space="preserve">
-    <value>A service name must not be null or empty.</value>
-  </data>
   <data name="net_allocate_ssl_context_failed" xml:space="preserve">
     <value>Failed to allocate SSL/TLS context, OpenSSL error - {0}.</value>
   </data>
diff --git a/src/libraries/System.Net.Security/src/System/Security/Authentication/ExtendedProtection/ServiceNameCollection.cs b/src/libraries/System.Net.Security/src/System/Security/Authentication/ExtendedProtection/ServiceNameCollection.cs
index 43260e11d3e7d2..88d8087c42c355 100644
--- a/src/libraries/System.Net.Security/src/System/Security/Authentication/ExtendedProtection/ServiceNameCollection.cs
+++ b/src/libraries/System.Net.Security/src/System/Security/Authentication/ExtendedProtection/ServiceNameCollection.cs
@@ -135,10 +135,7 @@ private void AddIfNew(IList serviceNames)
         /// </summary>
         private void AddIfNew(string serviceName)
         {
-            if (string.IsNullOrEmpty(serviceName))
-            {
-                throw new ArgumentException(SR.security_ServiceNameCollection_EmptyServiceName);
-            }
+            ArgumentException.ThrowIfNullOrEmpty(serviceName);
 
             serviceName = NormalizeServiceName(serviceName);
 
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/ServiceNameCollectionTest.cs b/src/libraries/System.Net.Security/tests/FunctionalTests/ServiceNameCollectionTest.cs
index 0fe53d560a4bfe..95458836321cda 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/ServiceNameCollectionTest.cs
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/ServiceNameCollectionTest.cs
@@ -17,14 +17,16 @@ public void Constructor_NullParam_Throws()
             Assert.Throws<ArgumentNullException>(() => new ServiceNameCollection(null));
         }
 
-        [Theory]
-        [InlineData(null)]
-        [InlineData("")]
-        public void Constructor_CollectionContainsNullOrEmpty_Throws(string item)
+        [Fact]
+        public void Constructor_CollectionContainsNullOrEmpty_Throws()
         {
-            AssertExtensions.Throws<ArgumentException>(null, () => new ServiceNameCollection(new[] { item }));
-            AssertExtensions.Throws<ArgumentException>(null, () => new ServiceNameCollection(new[] { "first", item }));
-            AssertExtensions.Throws<ArgumentException>(null, () => new ServiceNameCollection(new[] { item, "second" }));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => new ServiceNameCollection(new[] { (string)null }));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => new ServiceNameCollection(new[] { "first", null }));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => new ServiceNameCollection(new[] { null, "second" }));
+
+            AssertExtensions.Throws<ArgumentException>("serviceName", () => new ServiceNameCollection(new[] { "" }));
+            AssertExtensions.Throws<ArgumentException>("serviceName", () => new ServiceNameCollection(new[] { "first", "" }));
+            AssertExtensions.Throws<ArgumentException>("serviceName", () => new ServiceNameCollection(new[] { "", "second" }));
         }
 
         [Fact]
@@ -184,8 +186,8 @@ public void Enumerator_BehavesAsExpected()
         public void Merge_NullOrEmptyString_Throws()
         {
             var collection = new ServiceNameCollection(new[] { "first", "second" });
-            AssertExtensions.Throws<ArgumentException>(null, () => collection.Merge((string)null));
-            AssertExtensions.Throws<ArgumentException>(null, () => collection.Merge(string.Empty));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => collection.Merge((string)null));
+            AssertExtensions.Throws<ArgumentException>("serviceName", () => collection.Merge(string.Empty));
         }
 
         [Fact]
@@ -220,22 +222,22 @@ public void Merge_NullEnumerable_Throws()
             Assert.Throws<NullReferenceException>(() => collection.Merge((IEnumerable)null));
         }
 
-        [Theory]
-        [InlineData(null)]
-        [InlineData("")]
-        public void Merge_EnumerableContainingNullOrEmpty_Throws(string item)
+        [Fact]
+        public void Merge_EnumerableContainingNullOrEmpty_Throws()
         {
             var collection = new ServiceNameCollection(new[] { "first", "second" });
-            AssertExtensions.Throws<ArgumentException>(null, () => collection.Merge(new[] { item }));
-            AssertExtensions.Throws<ArgumentException>(null, () => collection.Merge(new[] { "third", item }));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => collection.Merge(new[] { (string)null }));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => collection.Merge(new[] { "third", null }));
+            AssertExtensions.Throws<ArgumentException>("serviceName", () => collection.Merge(new[] { "" }));
+            AssertExtensions.Throws<ArgumentException>("serviceName", () => collection.Merge(new[] { "third", "" }));
         }
 
         [Fact]
         public void Merge_NonStringEnumerable_Throws()
         {
             var collection = new ServiceNameCollection(new[] { "first", "second" });
-            AssertExtensions.Throws<ArgumentException>(null, () => collection.Merge(new[] { 3 }));
-            AssertExtensions.Throws<ArgumentException>(null, () => collection.Merge(new[] { new object() }));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => collection.Merge(new[] { 3 }));
+            AssertExtensions.Throws<ArgumentNullException>("serviceName", () => collection.Merge(new[] { new object() }));
         }
 
         public static object[][] MergeCollectionsTestData =
diff --git a/src/libraries/System.Net.WebHeaderCollection/src/Resources/Strings.resx b/src/libraries/System.Net.WebHeaderCollection/src/Resources/Strings.resx
index eb1e5a6487164e..86b29067c6aa94 100644
--- a/src/libraries/System.Net.WebHeaderCollection/src/Resources/Strings.resx
+++ b/src/libraries/System.Net.WebHeaderCollection/src/Resources/Strings.resx
@@ -1,4 +1,5 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -63,9 +64,6 @@
   <data name="net_headers_rsp" xml:space="preserve">
     <value>This collection holds request headers and cannot contain the specified response header.</value>
   </data>
-  <data name="net_emptyStringCall" xml:space="preserve">
-    <value>The parameter '{0}' cannot be an empty string.</value>
-  </data>
   <data name="net_WebHeaderInvalidControlChars" xml:space="preserve">
     <value>Specified value has invalid Control characters.</value>
   </data>
diff --git a/src/libraries/System.Net.WebHeaderCollection/src/System/Net/WebHeaderCollection.cs b/src/libraries/System.Net.WebHeaderCollection/src/System/Net/WebHeaderCollection.cs
index 1a97af3ccfb4fc..99563163a1ec79 100644
--- a/src/libraries/System.Net.WebHeaderCollection/src/System/Net/WebHeaderCollection.cs
+++ b/src/libraries/System.Net.WebHeaderCollection/src/System/Net/WebHeaderCollection.cs
@@ -344,14 +344,7 @@ public void Add(string header)
         public override void Add(string name, string? value)
 #pragma warning restore CS8765
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Format(SR.net_emptyStringCall, nameof(name)), nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             name = HttpValidationHelpers.CheckBadHeaderNameChars(name);
             value = HttpValidationHelpers.CheckBadHeaderValueChars(value);
diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
index 8b532738e4fe85..7b47a57ac9632e 100644
--- a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -1005,18 +1005,12 @@
   <data name="Argument_EmitWriteLineType" xml:space="preserve">
     <value>EmitWriteLine does not support this field or local type.</value>
   </data>
-  <data name="Argument_EmptyDecString" xml:space="preserve">
-    <value>Decimal separator cannot be the empty string.</value>
-  </data>
   <data name="Argument_EmptyFileName" xml:space="preserve">
     <value>Empty file name is not legal.</value>
   </data>
   <data name="Argument_EmptyName" xml:space="preserve">
     <value>Empty name is not legal.</value>
   </data>
-  <data name="Argument_EmptyPath" xml:space="preserve">
-    <value>Empty path name is not legal.</value>
-  </data>
   <data name="Argument_EmptyWaithandleArray" xml:space="preserve">
     <value>Waithandle array may not be empty.</value>
   </data>
@@ -1483,9 +1477,6 @@
   <data name="Argument_StringFirstCharIsZero" xml:space="preserve">
     <value>The first char in the string is the null character.</value>
   </data>
-  <data name="Argument_StringZeroLength" xml:space="preserve">
-    <value>String cannot be of zero length.</value>
-  </data>
   <data name="Argument_StructMustNotBeValueClass" xml:space="preserve">
     <value>The structure must not be a value class.</value>
   </data>
diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index 6c8c6bcfd3315a..321e2c0477ea87 100644
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -2141,7 +2141,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\DebugProvider.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\Stopwatch.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Diagnostics\Tracing\RuntimeEventSourceHelper.Unix.cs" Condition="'$(FeaturePerfTracing)' == 'true'" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Environment.Android.cs" Condition="'$(TargetsAndroid)' == 'true'"/>
+    <Compile Include="$(MSBuildThisFileDirectory)System\Environment.Android.cs" Condition="'$(TargetsAndroid)' == 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Environment.NoRegistry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Environment.UnixOrBrowser.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Environment.OSVersion.OSX.cs" Condition="'$(IsOSXLike)' == 'true' AND '$(TargetsMacCatalyst)' != 'true'" />
@@ -2186,10 +2186,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileStatus.SetTimes.OtherUnix.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetEUid.cs"
-             Link="Common\Interop\Unix\Interop.GetEUid.cs" />
-    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.IsMemberOfGroup.cs"
-             Link="Common\Interop\Unix\Interop.IsMemberOfGroup.cs" />
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetEUid.cs" Link="Common\Interop\Unix\Interop.GetEUid.cs" />
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.IsMemberOfGroup.cs" Link="Common\Interop\Unix\Interop.IsMemberOfGroup.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetPwUid.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.GetPwUid.cs</Link>
     </Compile>
@@ -2374,4 +2372,4 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryNegationOperators.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryPlusOperators.cs" />
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs
index 6b28c7b2a561d7..87488c1dfe280a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs
@@ -94,10 +94,7 @@ internal static void OnProcessExit()
         /// <returns>A return value of true represents that the switch was set and <paramref name="isEnabled"/> contains the value of the switch</returns>
         public static bool TryGetSwitch(string switchName, out bool isEnabled)
         {
-            if (switchName == null)
-                throw new ArgumentNullException(nameof(switchName));
-            if (switchName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(switchName));
+            ArgumentException.ThrowIfNullOrEmpty(switchName);
 
             if (s_switches != null)
             {
@@ -124,10 +121,7 @@ public static bool TryGetSwitch(string switchName, out bool isEnabled)
         /// <param name="isEnabled">The value to assign</param>
         public static void SetSwitch(string switchName, bool isEnabled)
         {
-            if (switchName == null)
-                throw new ArgumentNullException(nameof(switchName));
-            if (switchName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(switchName));
+            ArgumentException.ThrowIfNullOrEmpty(switchName);
 
             if (s_switches == null)
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/AppDomain.cs b/src/libraries/System.Private.CoreLib/src/System/AppDomain.cs
index 3e4e8a2317e4df..cff98ca55ee2f8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/AppDomain.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/AppDomain.cs
@@ -80,13 +80,10 @@ public event EventHandler? ProcessExit
 
         public string ApplyPolicy(string assemblyName)
         {
-            if (assemblyName == null)
-            {
-                throw new ArgumentNullException(nameof(assemblyName));
-            }
-            if (assemblyName.Length == 0 || assemblyName[0] == '\0')
+            ArgumentException.ThrowIfNullOrEmpty(assemblyName);
+            if (assemblyName[0] == '\0')
             {
-                throw new ArgumentException(SR.Argument_StringZeroLength, nameof(assemblyName));
+                throw new ArgumentException(SR.Argument_EmptyString, nameof(assemblyName));
             }
 
             return assemblyName;
diff --git a/src/libraries/System.Private.CoreLib/src/System/ApplicationId.cs b/src/libraries/System.Private.CoreLib/src/System/ApplicationId.cs
index ed537c244392bf..1511f8db1bd7ac 100644
--- a/src/libraries/System.Private.CoreLib/src/System/ApplicationId.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/ApplicationId.cs
@@ -12,10 +12,9 @@ public sealed class ApplicationId
 
         public ApplicationId(byte[] publicKeyToken, string name, Version version, string? processorArchitecture, string? culture)
         {
-            if (name == null) throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0) throw new ArgumentException(SR.Argument_EmptyString, nameof(name));
-            if (version == null) throw new ArgumentNullException(nameof(version));
-            if (publicKeyToken == null) throw new ArgumentNullException(nameof(publicKeyToken));
+            ArgumentException.ThrowIfNullOrEmpty(name);
+            ArgumentNullException.ThrowIfNull(version);
+            ArgumentNullException.ThrowIfNull(publicKeyToken);
 
             _publicKeyToken = (byte[])publicKeyToken.Clone();
             Name = name;
diff --git a/src/libraries/System.Private.CoreLib/src/System/ArgumentException.cs b/src/libraries/System.Private.CoreLib/src/System/ArgumentException.cs
index 3e223bd4789fdf..0e898e511a46ce 100644
--- a/src/libraries/System.Private.CoreLib/src/System/ArgumentException.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/ArgumentException.cs
@@ -10,6 +10,8 @@
 **
 =============================================================================*/
 
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
 namespace System
@@ -97,5 +99,24 @@ private void SetMessageField()
         }
 
         public virtual string? ParamName => _paramName;
+
+        /// <summary>Throws an exception if <paramref name="argument"/> is null or empty.</summary>
+        /// <param name="argument">The string argument to validate as non-null and non-empty.</param>
+        /// <param name="paramName">The name of the parameter with which <paramref name="argument"/> corresponds.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="argument"/> is null.</exception>
+        /// <exception cref="ArgumentException"><paramref name="argument"/> is empty.</exception>
+        public static void ThrowIfNullOrEmpty([NotNull] string? argument, [CallerArgumentExpression("argument")] string? paramName = null)
+        {
+            if (string.IsNullOrEmpty(argument))
+            {
+                ThrowNullOrEmptyException(argument, paramName);
+            }
+        }
+
+        [DoesNotReturn]
+        private static void ThrowNullOrEmptyException(string? argument, string? paramName) =>
+            throw (argument is null ?
+                new ArgumentNullException(paramName) :
+                new ArgumentException(SR.Argument_EmptyString, paramName));
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Environment.cs b/src/libraries/System.Private.CoreLib/src/System/Environment.cs
index 5a05ee1f33c71c..414db07d199e64 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Environment.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Environment.cs
@@ -77,12 +77,7 @@ public static string CurrentDirectory
             get => CurrentDirectoryCore;
             set
             {
-                if (value == null)
-                    throw new ArgumentNullException(nameof(value));
-
-                if (value.Length == 0)
-                    throw new ArgumentException(SR.Argument_PathEmpty, nameof(value));
-
+                ArgumentException.ThrowIfNullOrEmpty(value);
                 CurrentDirectoryCore = value;
             }
         }
@@ -239,11 +234,7 @@ private static bool ValidateAndConvertRegistryTarget(EnvironmentVariableTarget t
 
         private static void ValidateVariableAndValue(string variable, ref string? value)
         {
-            if (variable == null)
-                throw new ArgumentNullException(nameof(variable));
-
-            if (variable.Length == 0)
-                throw new ArgumentException(SR.Argument_StringZeroLength, nameof(variable));
+            ArgumentException.ThrowIfNullOrEmpty(variable);
 
             if (variable[0] == '\0')
                 throw new ArgumentException(SR.Argument_StringFirstCharIsZero, nameof(variable));
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs
index 78ca2a731f3d27..8387dd024d17fd 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs
@@ -80,27 +80,6 @@ public NumberFormatInfo()
         {
         }
 
-        private static void VerifyDecimalSeparator(string decSep, string propertyName)
-        {
-            if (decSep == null)
-            {
-                throw new ArgumentNullException(propertyName);
-            }
-
-            if (decSep.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyDecString, propertyName);
-            }
-        }
-
-        private static void VerifyGroupSeparator(string groupSep, string propertyName)
-        {
-            if (groupSep == null)
-            {
-                throw new ArgumentNullException(propertyName);
-            }
-        }
-
         private static void VerifyNativeDigits(string[] nativeDig, string propertyName)
         {
             if (nativeDig == null)
@@ -264,7 +243,7 @@ public string CurrencyDecimalSeparator
             set
             {
                 VerifyWritable();
-                VerifyDecimalSeparator(value, nameof(value));
+                ArgumentException.ThrowIfNullOrEmpty(value);
                 _currencyDecimalSeparator = value;
             }
         }
@@ -355,7 +334,7 @@ public string CurrencyGroupSeparator
             set
             {
                 VerifyWritable();
-                VerifyGroupSeparator(value, nameof(value));
+                ArgumentNullException.ThrowIfNull(value);
                 _currencyGroupSeparator = value;
             }
         }
@@ -542,7 +521,7 @@ public string NumberDecimalSeparator
             set
             {
                 VerifyWritable();
-                VerifyDecimalSeparator(value, nameof(value));
+                ArgumentException.ThrowIfNullOrEmpty(value);
                 _numberDecimalSeparator = value;
             }
         }
@@ -553,7 +532,7 @@ public string NumberGroupSeparator
             set
             {
                 VerifyWritable();
-                VerifyGroupSeparator(value, nameof(value));
+                ArgumentNullException.ThrowIfNull(value);
                 _numberGroupSeparator = value;
             }
         }
@@ -631,7 +610,7 @@ public string PercentDecimalSeparator
             set
             {
                 VerifyWritable();
-                VerifyDecimalSeparator(value, nameof(value));
+                ArgumentException.ThrowIfNullOrEmpty(value);
                 _percentDecimalSeparator = value;
             }
         }
@@ -642,7 +621,7 @@ public string PercentGroupSeparator
             set
             {
                 VerifyWritable();
-                VerifyGroupSeparator(value, nameof(value));
+                ArgumentNullException.ThrowIfNull(value);
                 _percentGroupSeparator = value;
             }
         }
@@ -652,11 +631,7 @@ public string PercentSymbol
             get => _percentSymbol;
             set
             {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-
+                ArgumentNullException.ThrowIfNull(value);
                 VerifyWritable();
                 _percentSymbol = value;
             }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Directory.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Directory.cs
index 2bfcd01604047f..eea2cda3f8c974 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Directory.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Directory.cs
@@ -13,11 +13,7 @@ public static partial class Directory
     {
         public static DirectoryInfo? GetParent(string path)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_PathEmpty, nameof(path));
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             string fullPath = Path.GetFullPath(path);
 
@@ -29,10 +25,7 @@ public static partial class Directory
 
         public static DirectoryInfo CreateDirectory(string path)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_PathEmpty, nameof(path));
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             string fullPath = Path.GetFullPath(path);
 
@@ -228,25 +221,15 @@ public static string GetDirectoryRoot(string path)
 
         public static void SetCurrentDirectory(string path)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_PathEmpty, nameof(path));
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             Environment.CurrentDirectory = Path.GetFullPath(path);
         }
 
         public static void Move(string sourceDirName, string destDirName)
         {
-            if (sourceDirName == null)
-                throw new ArgumentNullException(nameof(sourceDirName));
-            if (sourceDirName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(sourceDirName));
-
-            if (destDirName == null)
-                throw new ArgumentNullException(nameof(destDirName));
-            if (destDirName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(destDirName));
+            ArgumentException.ThrowIfNullOrEmpty(sourceDirName);
+            ArgumentException.ThrowIfNullOrEmpty(destDirName);
 
             string fullsourceDirName = Path.GetFullPath(sourceDirName);
             string sourcePath = PathInternal.EnsureTrailingSeparator(fullsourceDirName);
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/DirectoryInfo.cs b/src/libraries/System.Private.CoreLib/src/System/IO/DirectoryInfo.cs
index 1aeef2f7501a81..771b5e69a05ccd 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/DirectoryInfo.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/DirectoryInfo.cs
@@ -188,10 +188,7 @@ private IEnumerable<FileSystemInfo> InternalEnumerateInfos(
 
         public void MoveTo(string destDirName)
         {
-            if (destDirName == null)
-                throw new ArgumentNullException(nameof(destDirName));
-            if (destDirName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(destDirName));
+            ArgumentException.ThrowIfNullOrEmpty(destDirName);
 
             string destination = Path.GetFullPath(destDirName);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/File.cs b/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
index 007a16d590b0aa..d8b1124ed9b1b9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/File.cs
@@ -49,14 +49,8 @@ public static void Copy(string sourceFileName, string destFileName)
         /// </summary>
         public static void Copy(string sourceFileName, string destFileName, bool overwrite)
         {
-            if (sourceFileName == null)
-                throw new ArgumentNullException(nameof(sourceFileName), SR.ArgumentNull_FileName);
-            if (destFileName == null)
-                throw new ArgumentNullException(nameof(destFileName), SR.ArgumentNull_FileName);
-            if (sourceFileName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(sourceFileName));
-            if (destFileName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(destFileName));
+            ArgumentException.ThrowIfNullOrEmpty(sourceFileName);
+            ArgumentException.ThrowIfNullOrEmpty(destFileName);
 
             FileSystem.CopyFile(Path.GetFullPath(sourceFileName), Path.GetFullPath(destFileName), overwrite);
         }
@@ -292,12 +286,8 @@ public static byte[] ReadAllBytes(string path)
 
         public static void WriteAllBytes(string path, byte[] bytes)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path), SR.ArgumentNull_Path);
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
-            if (bytes == null)
-                throw new ArgumentNullException(nameof(bytes));
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(bytes);
 
             using SafeFileHandle sfh = OpenHandle(path, FileMode.Create, FileAccess.Write, FileShare.Read);
             RandomAccess.WriteAtOffset(sfh, bytes, 0);
@@ -418,14 +408,8 @@ public static void Move(string sourceFileName, string destFileName)
 
         public static void Move(string sourceFileName, string destFileName, bool overwrite)
         {
-            if (sourceFileName == null)
-                throw new ArgumentNullException(nameof(sourceFileName), SR.ArgumentNull_FileName);
-            if (destFileName == null)
-                throw new ArgumentNullException(nameof(destFileName), SR.ArgumentNull_FileName);
-            if (sourceFileName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(sourceFileName));
-            if (destFileName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(destFileName));
+            ArgumentException.ThrowIfNullOrEmpty(sourceFileName);
+            ArgumentException.ThrowIfNullOrEmpty(destFileName);
 
             string fullSourceFileName = Path.GetFullPath(sourceFileName);
             string fullDestFileName = Path.GetFullPath(destFileName);
@@ -609,12 +593,8 @@ private static async Task<byte[]> InternalReadAllBytesUnknownLengthAsync(SafeFil
 
         public static Task WriteAllBytesAsync(string path, byte[] bytes, CancellationToken cancellationToken = default(CancellationToken))
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path), SR.ArgumentNull_Path);
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
-            if (bytes == null)
-                throw new ArgumentNullException(nameof(bytes));
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(bytes);
 
             return cancellationToken.IsCancellationRequested
                 ? Task.FromCanceled(cancellationToken)
@@ -764,12 +744,8 @@ public static FileSystemInfo CreateSymbolicLink(string path, string pathToTarget
 
         private static void Validate(string path, Encoding encoding)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-            if (encoding == null)
-                throw new ArgumentNullException(nameof(encoding));
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(encoding);
         }
 
         private static byte[] ReadAllBytesUnknownLength(SafeFileHandle sfh)
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.cs
index 2ce33d996d61ea..0d9db030f900dd 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileInfo.cs
@@ -89,10 +89,7 @@ public StreamWriter AppendText()
 
         public FileInfo CopyTo(string destFileName, bool overwrite)
         {
-            if (destFileName == null)
-                throw new ArgumentNullException(nameof(destFileName), SR.ArgumentNull_FileName);
-            if (destFileName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(destFileName));
+            ArgumentException.ThrowIfNullOrEmpty(destFileName);
 
             string destinationPath = Path.GetFullPath(destFileName);
             FileSystem.CopyFile(FullPath, destinationPath, overwrite);
@@ -139,10 +136,7 @@ public void MoveTo(string destFileName)
         // This method does work across volumes.
         public void MoveTo(string destFileName, bool overwrite)
         {
-            if (destFileName == null)
-                throw new ArgumentNullException(nameof(destFileName));
-            if (destFileName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName, nameof(destFileName));
+            ArgumentException.ThrowIfNullOrEmpty(destFileName);
 
             string fullDestFileName = Path.GetFullPath(destFileName);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs
index b97194b86c5f0b..77685bb3b9a6a5 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs
@@ -173,19 +173,9 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
         /// <exception cref="T:System.IO.PathTooLongException">The specified path, file name, or both exceed the system-defined maximum length. </exception>
         public FileStream(string path, FileStreamOptions options)
         {
-            if (path is null)
-            {
-                throw new ArgumentNullException(nameof(path), SR.ArgumentNull_Path);
-            }
-            else if (path.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
-            }
-            else if (options is null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-            else if ((options.Access & FileAccess.Read) != 0 && options.Mode == FileMode.Append)
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(options);
+            if ((options.Access & FileAccess.Read) != 0 && options.Mode == FileMode.Append)
             {
                 throw new ArgumentException(SR.Argument_InvalidAppendMode, nameof(options));
             }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.cs
index 09f6000326111f..f475bcbfb59eb0 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.cs
@@ -7,15 +7,8 @@ internal static partial class FileSystem
     {
         internal static void VerifyValidPath(string path, string argName)
         {
-            if (path == null)
-            {
-                throw new ArgumentNullException(argName);
-            }
-            else if (path.Length == 0)
-            {
-                throw new ArgumentException(SR.Arg_PathEmpty, argName);
-            }
-            else if (path.Contains('\0'))
+            ArgumentException.ThrowIfNullOrEmpty(path, argName);
+            if (path.Contains('\0'))
             {
                 throw new ArgumentException(SR.Argument_InvalidPathChars, argName);
             }
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Path.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Path.Unix.cs
index f3ec19941c21b2..772440a293a52f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Path.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Path.Unix.cs
@@ -16,11 +16,7 @@ public static partial class Path
         // Expands the given path to a fully qualified path.
         public static string GetFullPath(string path)
         {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Arg_PathEmpty, nameof(path));
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             if (path.Contains('\0'))
                 throw new ArgumentException(SR.Argument_InvalidPathChars, nameof(path));
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.cs
index e3b419e278973e..5a067fd76ee463 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/Strategies/FileStreamHelpers.cs
@@ -53,14 +53,7 @@ e is NotSupportedException ||
 
         internal static void ValidateArguments(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
         {
-            if (path == null)
-            {
-                throw new ArgumentNullException(nameof(path), SR.ArgumentNull_Path);
-            }
-            else if (path.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(path));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(path);
 
             // don't include inheritable in our bounds check for share
             FileShare tempshare = share & ~FileShare.Inheritable;
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs b/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
index b18aff879a87e6..785e2c8e4a0b6f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
@@ -210,12 +210,9 @@ public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteO
 
         private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
         {
-            ValidateArgs(path, encoding);
-
-            if (options is null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(encoding);
+            ArgumentNullException.ThrowIfNull(options);
             if ((options.Access & FileAccess.Read) == 0)
             {
                 throw new ArgumentException(SR.Argument_StreamNotReadable, nameof(options));
@@ -226,23 +223,16 @@ private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, Fi
 
         private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, int bufferSize)
         {
-            ValidateArgs(path, encoding);
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(encoding);
             if (bufferSize <= 0)
+            {
                 throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
+            }
 
             return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize);
         }
 
-        private static void ValidateArgs(string path, Encoding encoding)
-        {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-            if (encoding == null)
-                throw new ArgumentNullException(nameof(encoding));
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyPath);
-        }
-
         public override void Close()
         {
             Dispose(true);
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs b/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs
index 7ba362604d01c7..c591e51f15e232 100644
--- a/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs
@@ -166,12 +166,9 @@ public StreamWriter(string path, Encoding encoding, FileStreamOptions options)
 
         private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
         {
-            ValidateArgs(path, encoding);
-
-            if (options is null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(encoding);
+            ArgumentNullException.ThrowIfNull(options);
             if ((options.Access & FileAccess.Write) == 0)
             {
                 throw new ArgumentException(SR.Argument_StreamNotWritable, nameof(options));
@@ -182,23 +179,16 @@ private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, Fi
 
         private static Stream ValidateArgsAndOpenPath(string path, bool append, Encoding encoding, int bufferSize)
         {
-            ValidateArgs(path, encoding);
+            ArgumentException.ThrowIfNullOrEmpty(path);
+            ArgumentNullException.ThrowIfNull(encoding);
             if (bufferSize <= 0)
+            {
                 throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
+            }
 
             return new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read, DefaultFileStreamBufferSize);
         }
 
-        private static void ValidateArgs(string path, Encoding encoding)
-        {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-            if (encoding == null)
-                throw new ArgumentNullException(nameof(encoding));
-            if (path.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyPath);
-        }
-
         public override void Close()
         {
             Dispose(true);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/OSPlatform.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/OSPlatform.cs
index cf6c8af7a28ac7..09265f93c643f1 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/OSPlatform.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/OSPlatform.cs
@@ -19,9 +19,7 @@ namespace System.Runtime.InteropServices
 
         private OSPlatform(string osPlatform)
         {
-            if (osPlatform == null) throw new ArgumentNullException(nameof(osPlatform));
-            if (osPlatform.Length == 0) throw new ArgumentException(SR.Argument_EmptyString, nameof(osPlatform));
-
+            ArgumentException.ThrowIfNullOrEmpty(osPlatform);
             Name = osPlatform;
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs
index 289bb93be4b1ec..c6b3478cf9bb69 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs
@@ -422,15 +422,7 @@ public Assembly LoadFromStream(Stream assembly, Stream? assemblySymbols)
         // platform-independent way. The DLL is loaded with default load flags.
         protected IntPtr LoadUnmanagedDllFromPath(string unmanagedDllPath)
         {
-            if (unmanagedDllPath == null)
-            {
-                throw new ArgumentNullException(nameof(unmanagedDllPath));
-            }
-
-            if (unmanagedDllPath.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyPath, nameof(unmanagedDllPath));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(unmanagedDllPath);
 
             if (PathInternal.IsPartiallyQualified(unmanagedDllPath))
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Versioning/FrameworkName.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Versioning/FrameworkName.cs
index c96729d8af4c8a..5c492e7657ff19 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Versioning/FrameworkName.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Versioning/FrameworkName.cs
@@ -96,20 +96,9 @@ public FrameworkName(string identifier, Version version)
 
         public FrameworkName(string identifier, Version version, string? profile)
         {
-            if (identifier == null)
-            {
-                throw new ArgumentNullException(nameof(identifier));
-            }
-
-            identifier = identifier.Trim();
-            if (identifier.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyString, nameof(identifier));
-            }
-            if (version == null)
-            {
-                throw new ArgumentNullException(nameof(version));
-            }
+            identifier = identifier?.Trim()!;
+            ArgumentException.ThrowIfNullOrEmpty(identifier);
+            ArgumentNullException.ThrowIfNull(version);
 
             _identifier = identifier;
             _version = version;
@@ -122,14 +111,7 @@ public FrameworkName(string identifier, Version version, string? profile)
         //  - The version string must be in the System.Version format; an optional "v" or "V" prefix is allowed
         public FrameworkName(string frameworkName)
         {
-            if (frameworkName == null)
-            {
-                throw new ArgumentNullException(nameof(frameworkName));
-            }
-            if (frameworkName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyString, nameof(frameworkName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(frameworkName);
 
             string[] components = frameworkName.Split(ComponentSeparator);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/String.Manipulation.cs b/src/libraries/System.Private.CoreLib/src/System/String.Manipulation.cs
index 0143c030432f5f..0097b92631ff0e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/String.Manipulation.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/String.Manipulation.cs
@@ -925,15 +925,7 @@ public string Replace(string oldValue, string? newValue, StringComparison compar
 
         private string ReplaceCore(string oldValue, string? newValue, CompareInfo? ci, CompareOptions options)
         {
-            if (oldValue is null)
-            {
-                throw new ArgumentNullException(nameof(oldValue));
-            }
-
-            if (oldValue.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_StringZeroLength, nameof(oldValue));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(oldValue);
 
             // If they asked to replace oldValue with a null, replace all occurrences
             // with the empty string. AsSpan() will normalize appropriately.
@@ -1054,14 +1046,7 @@ public string Replace(char oldChar, char newChar)
 
         public string Replace(string oldValue, string? newValue)
         {
-            if (oldValue is null)
-            {
-                throw new ArgumentNullException(nameof(oldValue));
-            }
-            if (oldValue.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_StringZeroLength, nameof(oldValue));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(oldValue);
 
             // If newValue is null, treat it as an empty string.  Callers use this to remove the oldValue.
             newValue ??= Empty;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs b/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs
index 1f58c7185f6c63..9b6eb47408c485 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs
@@ -1959,14 +1959,7 @@ public StringBuilder Replace(string oldValue, string? newValue, int startIndex,
             {
                 throw new ArgumentOutOfRangeException(nameof(count), SR.ArgumentOutOfRange_Index);
             }
-            if (oldValue == null)
-            {
-                throw new ArgumentNullException(nameof(oldValue));
-            }
-            if (oldValue.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(oldValue));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(oldValue);
 
             newValue ??= string.Empty;
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Windows.cs
index 20cb741435f0cf..bf4427fa36c3e8 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/EventWaitHandle.Windows.cs
@@ -44,10 +44,7 @@ private void CreateEventCore(bool initialState, EventResetMode mode, string? nam
         private static OpenExistingResult OpenExistingWorker(string name, out EventWaitHandle? result)
         {
 #if TARGET_WINDOWS
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             result = null;
             SafeWaitHandle myHandle = Interop.Kernel32.OpenEvent(AccessRights, false, name);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Unix.cs
index 61be44de4a1b84..2f6e63aacec799 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Unix.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Unix.cs
@@ -29,15 +29,7 @@ private void CreateMutexCore(bool initiallyOwned, string? name, out bool created
 
         private static OpenExistingResult OpenExistingWorker(string name, out Mutex? result)
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             OpenExistingResult status = WaitSubsystem.OpenNamedMutex(name, out SafeWaitHandle? safeWaitHandle);
             result = status == OpenExistingResult.Success ? new Mutex(safeWaitHandle!) : null;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Windows.cs
index 48f23264a7f6c1..f1a22346801d4b 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Mutex.Windows.cs
@@ -41,15 +41,7 @@ private void CreateMutexCore(bool initiallyOwned, string? name, out bool created
 
         private static OpenExistingResult OpenExistingWorker(string name, out Mutex? result)
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             result = null;
             // To allow users to view & edit the ACL's, call OpenMutex
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Windows.cs
index d92e9c9f887718..013023fe212a84 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Windows.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Semaphore.Windows.cs
@@ -45,10 +45,7 @@ private void CreateSemaphoreCore(int initialCount, int maximumCount, string? nam
         private static OpenExistingResult OpenExistingWorker(string name, out Semaphore? result)
         {
 #if TARGET_WINDOWS
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             // Pass false to OpenSemaphore to prevent inheritedHandles
             SafeWaitHandle myHandle = Interop.Kernel32.OpenSemaphore(AccessRights, false, name);
diff --git a/src/libraries/System.Private.Xml.Linq/src/Resources/Strings.resx b/src/libraries/System.Private.Xml.Linq/src/Resources/Strings.resx
index 6b427d8b7a9af9..0f1c99d02d250f 100644
--- a/src/libraries/System.Private.Xml.Linq/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.Xml.Linq/src/Resources/Strings.resx
@@ -1,4 +1,5 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
     <xsd:element name="root" msdata:IsDataSet="true">
@@ -75,9 +76,6 @@
   <data name="Argument_InvalidPIName" xml:space="preserve">
     <value>'{0}' is an invalid name for a processing instruction.</value>
   </data>
-  <data name="Argument_InvalidPrefix" xml:space="preserve">
-    <value>'{0}' is an invalid prefix.</value>
-  </data>
   <data name="Argument_MustBeDerivedFrom" xml:space="preserve">
     <value>The argument must be derived from {0}.</value>
   </data>
diff --git a/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XElement.cs b/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XElement.cs
index 283b42a82e6cda..311a4855daa3e6 100644
--- a/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XElement.cs
+++ b/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XElement.cs
@@ -478,8 +478,7 @@ public XNamespace GetDefaultNamespace()
         /// <returns>An <see cref="XNamespace"/> for the namespace bound to the prefix</returns>
         public XNamespace? GetNamespaceOfPrefix(string prefix)
         {
-            if (prefix == null) throw new ArgumentNullException(nameof(prefix));
-            if (prefix.Length == 0) throw new ArgumentException(SR.Format(SR.Argument_InvalidPrefix, prefix));
+            ArgumentException.ThrowIfNullOrEmpty(prefix);
             if (prefix == "xmlns") return XNamespace.Xmlns;
             string? namespaceName = GetNamespaceOfPrefixInScope(prefix, null);
             if (namespaceName != null) return XNamespace.Get(namespaceName);
diff --git a/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XName.cs b/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XName.cs
index 15d39872865561..1b673a0026bfd5 100644
--- a/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XName.cs
+++ b/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XName.cs
@@ -71,8 +71,7 @@ public override string ToString()
         /// </returns>
         public static XName Get(string expandedName)
         {
-            if (expandedName == null) throw new ArgumentNullException(nameof(expandedName));
-            if (expandedName.Length == 0) throw new ArgumentException(SR.Format(SR.Argument_InvalidExpandedName, expandedName));
+            ArgumentException.ThrowIfNullOrEmpty(expandedName);
             if (expandedName[0] == '{')
             {
                 int i = expandedName.LastIndexOf('}');
diff --git a/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMElement.cs b/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMElement.cs
index 2a33a1a0b29b9e..c09c64b9eeafbd 100644
--- a/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMElement.cs
+++ b/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMElement.cs
@@ -784,7 +784,7 @@ public void ElementGetNamespaceOfPrefix()
             XElement e = new XElement(ns + "foo");
 
             Assert.Throws<ArgumentNullException>(() => e.GetNamespaceOfPrefix(null));
-            AssertExtensions.Throws<ArgumentException>(null, () => e.GetNamespaceOfPrefix(string.Empty));
+            AssertExtensions.Throws<ArgumentException>("prefix", () => e.GetNamespaceOfPrefix(string.Empty));
 
             XNamespace n = e.GetNamespaceOfPrefix("xmlns");
             Assert.Equal("http://www.w3.org/2000/xmlns/", n.NamespaceName);
diff --git a/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMXName.cs b/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMXName.cs
index bee81c2d7aff1b..a8ff6727750322 100644
--- a/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMXName.cs
+++ b/src/libraries/System.Private.Xml.Linq/tests/SDMSample/SDMXName.cs
@@ -29,7 +29,7 @@ public void NameGetInvalid()
             Assert.Throws<ArgumentNullException>(() => XName.Get(null));
             Assert.Throws<ArgumentNullException>(() => XName.Get(null, "foo"));
             Assert.Throws<ArgumentNullException>(() => XName.Get(string.Empty, "foo"));
-            AssertExtensions.Throws<ArgumentException>(null, () => XName.Get(string.Empty));
+            AssertExtensions.Throws<ArgumentException>("expandedName", () => XName.Get(string.Empty));
             AssertExtensions.Throws<ArgumentException>(null, () => XName.Get("{}"));
             AssertExtensions.Throws<ArgumentException>(null, () => XName.Get("{foo}"));
         }
diff --git a/src/libraries/System.Private.Xml.Linq/tests/Streaming/StreamingOutput.cs b/src/libraries/System.Private.Xml.Linq/tests/Streaming/StreamingOutput.cs
index 2086d14b9dba86..f3c4a8e0946674 100644
--- a/src/libraries/System.Private.Xml.Linq/tests/Streaming/StreamingOutput.cs
+++ b/src/libraries/System.Private.Xml.Linq/tests/Streaming/StreamingOutput.cs
@@ -60,7 +60,7 @@ public void XNameAsNullConstructor()
         [Fact]
         public void XNameAsEmptyStringConstructor()
         {
-            AssertExtensions.Throws<ArgumentException>(null, () => new XStreamingElement(string.Empty));
+            AssertExtensions.Throws<ArgumentException>("expandedName", () => new XStreamingElement(string.Empty));
             Assert.Throws<XmlException>(() => new XStreamingElement(" "));
         }
 
diff --git a/src/libraries/System.Private.Xml.Linq/tests/axes/InvalidParamValidation.cs b/src/libraries/System.Private.Xml.Linq/tests/axes/InvalidParamValidation.cs
index e9e11ef002901f..953e692c6ca1cc 100644
--- a/src/libraries/System.Private.Xml.Linq/tests/axes/InvalidParamValidation.cs
+++ b/src/libraries/System.Private.Xml.Linq/tests/axes/InvalidParamValidation.cs
@@ -50,9 +50,9 @@ public static void NullXNameTestAttributes()
         public static void InvalidXNameTest()
         {
             Assert.Throws<XmlException>(() => { TestData.GetDocumentWithContacts().Root.Attribute("*&^%_#@!"); });
-            AssertExtensions.Throws<ArgumentException>(null, () => { TestData.GetDocumentWithContacts().Root.Attribute(""); });
+            AssertExtensions.Throws<ArgumentException>("expandedName", () => { TestData.GetDocumentWithContacts().Root.Attribute(""); });
             Assert.Throws<XmlException>(() => { TestData.GetDocumentWithContacts().Root.Attributes("*&^%_#@!"); });
-            AssertExtensions.Throws<ArgumentException>(null, () => { TestData.GetDocumentWithContacts().Root.Attributes(""); });
+            AssertExtensions.Throws<ArgumentException>("expandedName", () => { TestData.GetDocumentWithContacts().Root.Attributes(""); });
         }
     }
 
diff --git a/src/libraries/System.Private.Xml/src/Resources/Strings.resx b/src/libraries/System.Private.Xml/src/Resources/Strings.resx
index 8fc3de76fe51cd..f9f838382dcbd4 100644
--- a/src/libraries/System.Private.Xml/src/Resources/Strings.resx
+++ b/src/libraries/System.Private.Xml/src/Resources/Strings.resx
@@ -390,9 +390,6 @@
   <data name="Xml_NotEnoughSpaceForSurrogatePair" xml:space="preserve">
     <value>The buffer is not large enough to fit a surrogate pair. Please provide a buffer of size at least 2 characters.</value>
   </data>
-  <data name="Xml_EmptyUrl" xml:space="preserve">
-    <value>The URL cannot be empty.</value>
-  </data>
   <data name="Xml_UnexpectedNodeInSimpleContent" xml:space="preserve">
     <value>Unexpected node type {0}. {1} method can only be called on elements with simple or empty content.</value>
   </data>
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs
index 599ff04f757fd1..b0e5d48b2d6967 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReader.cs
@@ -1635,12 +1635,7 @@ internal static ConformanceLevel GetV1ConformanceLevel(XmlReader reader)
         // Creates an XmlReader for parsing XML from the given Uri.
         public static XmlReader Create(string inputUri)
         {
-            ArgumentNullException.ThrowIfNull(inputUri);
-
-            if (inputUri.Length == 0)
-            {
-                throw new ArgumentException(SR.XmlConvert_BadUri, nameof(inputUri));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(inputUri);
 
             // Avoid using XmlReader.Create(string, XmlReaderSettings), as it references a lot of types
             // that then can't be trimmed away.
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReaderSettings.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReaderSettings.cs
index 1a7723bc697ab2..68adf4d128807b 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReaderSettings.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlReaderSettings.cs
@@ -318,12 +318,7 @@ public XmlReaderSettings Clone()
 
         internal XmlReader CreateReader(string inputUri, XmlParserContext? inputContext)
         {
-            ArgumentNullException.ThrowIfNull(inputUri);
-
-            if (inputUri.Length == 0)
-            {
-                throw new ArgumentException(SR.XmlConvert_BadUri, nameof(inputUri));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(inputUri);
 
             // resolve and open the url
             XmlResolver tmpResolver = GetXmlResolver() ?? new XmlUrlResolver();
diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs
index 6c7614308a93d0..2222a29d20685f 100644
--- a/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs
+++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/XmlTextReaderImpl.cs
@@ -567,15 +567,7 @@ internal XmlTextReaderImpl(string xmlFragment, XmlParserContext? context)
 
         public XmlTextReaderImpl(string url, XmlNameTable nt) : this(nt)
         {
-            if (url == null)
-            {
-                throw new ArgumentNullException(nameof(url));
-            }
-
-            if (url.Length == 0)
-            {
-                throw new ArgumentException(SR.Xml_EmptyUrl, nameof(url));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(url);
 
             _namespaceManager = new XmlNamespaceManager(nt);
 
diff --git a/src/libraries/System.Reflection/tests/AssemblyTests.cs b/src/libraries/System.Reflection/tests/AssemblyTests.cs
index db230110beed73..1a85f648f83641 100644
--- a/src/libraries/System.Reflection/tests/AssemblyTests.cs
+++ b/src/libraries/System.Reflection/tests/AssemblyTests.cs
@@ -161,7 +161,7 @@ public void GetFile()
             if (asm.Location.Length > 0)
             {
                 Assert.Throws<ArgumentNullException>(() => asm.GetFile(null));
-                AssertExtensions.Throws<ArgumentException>(null, () => asm.GetFile(""));
+                Assert.Throws<ArgumentException>(() => asm.GetFile(""));
                 Assert.Null(asm.GetFile("NonExistentfile.dll"));
                 Assert.NotNull(asm.GetFile("System.Reflection.Tests.dll"));
 
diff --git a/src/libraries/System.Reflection/tests/GetTypeTests.cs b/src/libraries/System.Reflection/tests/GetTypeTests.cs
index 73ff198d9eab9a..5cc854e1f3d1d2 100644
--- a/src/libraries/System.Reflection/tests/GetTypeTests.cs
+++ b/src/libraries/System.Reflection/tests/GetTypeTests.cs
@@ -39,27 +39,27 @@ public void GetType_EmptyString()
             AssertExtensions.Throws<ArgumentException>("typeName@0", () => Type.GetType(aqn, throwOnError: true, ignoreCase: true));
 
             // Assembly.GetType
-            AssertExtensions.Throws<ArgumentException>(null, () => a.GetType(typeName));
+            Assert.Throws<ArgumentException>(() => a.GetType(typeName));
             Assert.Null(a.GetType(aqn));
 
-            AssertExtensions.Throws<ArgumentException>(null, () => a.GetType(typeName, throwOnError: false, ignoreCase: false));
-            AssertExtensions.Throws<ArgumentException>(null, () => a.GetType(typeName, throwOnError: false, ignoreCase: true));
+            Assert.Throws<ArgumentException>(() => a.GetType(typeName, throwOnError: false, ignoreCase: false));
+            Assert.Throws<ArgumentException>(() => a.GetType(typeName, throwOnError: false, ignoreCase: true));
             Assert.Null(a.GetType(aqn, throwOnError: false, ignoreCase: false));
             Assert.Null(a.GetType(aqn, throwOnError: false, ignoreCase: true));
 
-            AssertExtensions.Throws<ArgumentException>(null, () => a.GetType(typeName, throwOnError: true, ignoreCase: false));
-            AssertExtensions.Throws<ArgumentException>(null, () => a.GetType(typeName, throwOnError: true, ignoreCase: true));
+            Assert.Throws<ArgumentException>(() => a.GetType(typeName, throwOnError: true, ignoreCase: false));
+            Assert.Throws<ArgumentException>(() => a.GetType(typeName, throwOnError: true, ignoreCase: true));
             AssertExtensions.Throws<ArgumentException>("typeName@0", () => a.GetType(aqn, throwOnError: true, ignoreCase: false));
             AssertExtensions.Throws<ArgumentException>("typeName@0", () => a.GetType(aqn, throwOnError: true, ignoreCase: true));
 
             // Module.GetType
-            AssertExtensions.Throws<ArgumentException>(null, () => m.GetType(typeName, throwOnError: false, ignoreCase: false));
-            AssertExtensions.Throws<ArgumentException>(null, () => m.GetType(typeName, throwOnError: false, ignoreCase: true));
+            Assert.Throws<ArgumentException>(() => m.GetType(typeName, throwOnError: false, ignoreCase: false));
+            Assert.Throws<ArgumentException>(() => m.GetType(typeName, throwOnError: false, ignoreCase: true));
             Assert.Null(m.GetType(aqn, throwOnError: false, ignoreCase: false));
             Assert.Null(m.GetType(aqn, throwOnError: false, ignoreCase: true));
 
-            AssertExtensions.Throws<ArgumentException>(null, () => m.GetType(typeName, throwOnError: true, ignoreCase: false));
-            AssertExtensions.Throws<ArgumentException>(null, () => m.GetType(typeName, throwOnError: true, ignoreCase: true));
+            Assert.Throws<ArgumentException>(() => m.GetType(typeName, throwOnError: true, ignoreCase: false));
+            Assert.Throws<ArgumentException>(() => m.GetType(typeName, throwOnError: true, ignoreCase: true));
             AssertExtensions.Throws<ArgumentException>("typeName@0", () => m.GetType(aqn, throwOnError: true, ignoreCase: false));
             AssertExtensions.Throws<ArgumentException>("typeName@0", () => m.GetType(aqn, throwOnError: true, ignoreCase: true));
         }
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
index 7e67104fd9d2cd..cf8690cc422e83 100644
--- a/src/libraries/System.Runtime/ref/System.Runtime.cs
+++ b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -277,6 +277,7 @@ public ArgumentException(string? message, string? paramName, System.Exception? i
         public override string Message { get { throw null; } }
         public virtual string? ParamName { get { throw null; } }
         public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+        public static void ThrowIfNullOrEmpty([System.Diagnostics.CodeAnalysis.NotNullAttribute] string? argument, [System.Runtime.CompilerServices.CallerArgumentExpression("argument")] string? paramName = null) { throw null; }
     }
     public partial class ArgumentNullException : System.ArgumentException
     {
diff --git a/src/libraries/System.Runtime/tests/System/ArgumentExceptionTests.cs b/src/libraries/System.Runtime/tests/System/ArgumentExceptionTests.cs
index 1880ea5d31c415..d2d9804912e944 100644
--- a/src/libraries/System.Runtime/tests/System/ArgumentExceptionTests.cs
+++ b/src/libraries/System.Runtime/tests/System/ArgumentExceptionTests.cs
@@ -60,5 +60,32 @@ public static void Ctor_String_String_Exception()
             Assert.Contains(message, exception.Message);
             Assert.Contains(argumentName, exception.Message);
         }
+
+        [Fact]
+        public static void ThrowIfNullOrEmpty_ThrowsForInvalidInput()
+        {
+            AssertExtensions.Throws<ArgumentNullException>(null, () => ArgumentException.ThrowIfNullOrEmpty(null, null));
+            AssertExtensions.Throws<ArgumentNullException>("something", () => ArgumentException.ThrowIfNullOrEmpty(null, "something"));
+
+            AssertExtensions.Throws<ArgumentException>(null, () => ArgumentException.ThrowIfNullOrEmpty("", null));
+            AssertExtensions.Throws<ArgumentException>("something", () => ArgumentException.ThrowIfNullOrEmpty("", "something"));
+
+            ArgumentException.ThrowIfNullOrEmpty(" ");
+            ArgumentException.ThrowIfNullOrEmpty(" ", "something");
+            ArgumentException.ThrowIfNullOrEmpty("abc", "something");
+        }
+
+        [Fact]
+        public static void ThrowIfNullOrEmpty_UsesArgumentExpression_ParameterNameMatches()
+        {
+            string someString = null;
+            AssertExtensions.Throws<ArgumentNullException>(nameof(someString), () => ArgumentException.ThrowIfNullOrEmpty(someString));
+
+            someString = "";
+            AssertExtensions.Throws<ArgumentException>(nameof(someString), () => ArgumentException.ThrowIfNullOrEmpty(someString));
+
+            someString = "abc";
+            ArgumentException.ThrowIfNullOrEmpty(someString);
+        }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
index bc868c30ba2dda..06bd0851e990e9 100644
--- a/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.Cng/src/Resources/Strings.resx
@@ -117,15 +117,6 @@
   <data name="Cryptography_Encryption_MessageTooLong" xml:space="preserve">
     <value>The message exceeds the maximum allowable length for the chosen options ({0}).</value>
   </data>
-  <data name="Cryptography_HashAlgorithmNameNullOrEmpty" xml:space="preserve">
-    <value>The hash algorithm name cannot be null or empty.</value>
-  </data>
-  <data name="Cryptography_InvalidAlgorithmGroup" xml:space="preserve">
-    <value>The algorithm group '{0}' is invalid.</value>
-  </data>
-  <data name="Cryptography_InvalidAlgorithmName" xml:space="preserve">
-    <value>The algorithm name '{0}' is invalid.</value>
-  </data>
   <data name="Cryptography_InvalidCipherMode" xml:space="preserve">
     <value>Specified cipher mode is not valid for this algorithm.</value>
   </data>
@@ -159,18 +150,12 @@
   <data name="Cryptography_InvalidIVSize" xml:space="preserve">
     <value>Specified initialization vector (IV) does not match the block size for this algorithm.</value>
   </data>
-  <data name="Cryptography_InvalidKeyBlobFormat" xml:space="preserve">
-    <value>The key blob format '{0}' is invalid.</value>
-  </data>
   <data name="Cryptography_InvalidKeySize" xml:space="preserve">
     <value>Specified key is not a valid size for this algorithm.</value>
   </data>
   <data name="Cryptography_InvalidPadding" xml:space="preserve">
     <value>Padding is invalid and cannot be removed.</value>
   </data>
-  <data name="Cryptography_InvalidProviderName" xml:space="preserve">
-    <value>The provider name '{0}' is invalid.</value>
-  </data>
   <data name="Cryptography_InvalidRsaParameters" xml:space="preserve">
     <value>The specified RSA parameters are not valid. Exponent and Modulus are required. If D is present, it must have the same length as Modulus. If D is present, P, Q, DP, DQ, and InverseQ are required and must have half the length of Modulus, rounded up, otherwise they must be omitted.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithm.cs b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithm.cs
index 52ba6b6a7d5db8..28de479aae4f66 100644
--- a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithm.cs
+++ b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithm.cs
@@ -17,11 +17,7 @@ public sealed class CngAlgorithm : IEquatable<CngAlgorithm>
     {
         public CngAlgorithm(string algorithm)
         {
-            if (algorithm == null)
-                throw new ArgumentNullException(nameof(algorithm));
-            if (algorithm.Length == 0)
-                throw new ArgumentException(SR.Format(SR.Cryptography_InvalidAlgorithmName, algorithm), nameof(algorithm));
-
+            ArgumentException.ThrowIfNullOrEmpty(algorithm);
             _algorithm = algorithm;
         }
 
diff --git a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithmGroup.cs b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithmGroup.cs
index 0c7ffe55998c08..b65eb4c3d78d4f 100644
--- a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithmGroup.cs
+++ b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngAlgorithmGroup.cs
@@ -18,11 +18,7 @@ public sealed class CngAlgorithmGroup : IEquatable<CngAlgorithmGroup>
     {
         public CngAlgorithmGroup(string algorithmGroup)
         {
-            if (algorithmGroup == null)
-                throw new ArgumentNullException(nameof(algorithmGroup));
-            if (algorithmGroup.Length == 0)
-                throw new ArgumentException(SR.Format(SR.Cryptography_InvalidAlgorithmGroup, algorithmGroup), nameof(algorithmGroup));
-
+            ArgumentException.ThrowIfNullOrEmpty(algorithmGroup);
             _algorithmGroup = algorithmGroup;
         }
 
diff --git a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngKeyBlobFormat.cs b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngKeyBlobFormat.cs
index 81d4b170dccb7d..baf07295805da6 100644
--- a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngKeyBlobFormat.cs
+++ b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngKeyBlobFormat.cs
@@ -18,11 +18,7 @@ public sealed class CngKeyBlobFormat : IEquatable<CngKeyBlobFormat>
     {
         public CngKeyBlobFormat(string format)
         {
-            if (format == null)
-                throw new ArgumentNullException(nameof(format));
-            if (format.Length == 0)
-                throw new ArgumentException(SR.Format(SR.Cryptography_InvalidKeyBlobFormat, format), nameof(format));
-
+            ArgumentException.ThrowIfNullOrEmpty(format);
             _format = format;
         }
 
diff --git a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngProvider.cs b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngProvider.cs
index aad1695cef02d0..61d631c7be4cdd 100644
--- a/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngProvider.cs
+++ b/src/libraries/System.Security.Cryptography.Cng/src/System/Security/Cryptography/CngProvider.cs
@@ -17,11 +17,7 @@ public sealed class CngProvider : IEquatable<CngProvider>
     {
         public CngProvider(string provider)
         {
-            if (provider == null)
-                throw new ArgumentNullException(nameof(provider));
-            if (provider.Length == 0)
-                throw new ArgumentException(SR.Format(SR.Cryptography_InvalidProviderName, provider), nameof(provider));
-
+            ArgumentException.ThrowIfNullOrEmpty(provider);
             _provider = provider;
         }
 
diff --git a/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx
index cf77078e43c081..16480c8488ab7a 100644
--- a/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.Csp/src/Resources/Strings.resx
@@ -143,9 +143,6 @@
   <data name="Cryptography_CSP_WrongKeySpec" xml:space="preserve">
     <value>The specified cryptographic service provider (CSP) does not support this key algorithm: {0}.</value>
   </data>
-  <data name="Cryptography_HashAlgorithmNameNullOrEmpty" xml:space="preserve">
-    <value>The hash algorithm name cannot be null or empty.</value>
-  </data>
   <data name="Cryptography_InvalidDSASignatureSize" xml:space="preserve">
     <value>Length of the DSA signature was not 40 bytes.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/RSACryptoServiceProvider.Windows.cs b/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/RSACryptoServiceProvider.Windows.cs
index 6843a3aa30fca2..005988e00c8f17 100644
--- a/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/RSACryptoServiceProvider.Windows.cs
+++ b/src/libraries/System.Security.Cryptography.Csp/src/System/Security/Cryptography/RSACryptoServiceProvider.Windows.cs
@@ -678,12 +678,9 @@ public override byte[] SignHash(
             HashAlgorithmName hashAlgorithm,
             RSASignaturePadding padding)
         {
-            if (hash == null)
-                throw new ArgumentNullException(nameof(hash));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(hash);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
             if (padding != RSASignaturePadding.Pkcs1)
                 throw PaddingModeNotSupported();
 
@@ -696,14 +693,10 @@ public override bool VerifyHash(
             HashAlgorithmName hashAlgorithm,
             RSASignaturePadding padding)
         {
-            if (hash == null)
-                throw new ArgumentNullException(nameof(hash));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(hash);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
             if (padding != RSASignaturePadding.Pkcs1)
                 throw PaddingModeNotSupported();
 
@@ -735,11 +728,6 @@ private static Exception PaddingModeNotSupported()
             return new CryptographicException(SR.Cryptography_InvalidPaddingMode);
         }
 
-        private static Exception HashAlgorithmNameNullOrEmpty()
-        {
-            return new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, "hashAlgorithm");
-        }
-
         private void ThrowIfDisposed()
         {
             if (_disposed)
diff --git a/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx
index 11c10ccd63a311..f44ab3d72e541c 100644
--- a/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.OpenSsl/src/Resources/Strings.resx
@@ -137,9 +137,6 @@
   <data name="Cryptography_Encryption_MessageTooLong" xml:space="preserve">
     <value>The message exceeds the maximum allowable length for the chosen options ({0}).</value>
   </data>
-  <data name="Cryptography_HashAlgorithmNameNullOrEmpty" xml:space="preserve">
-    <value>The hash algorithm name cannot be null or empty.</value>
-  </data>
   <data name="Cryptography_CurveNotSupported" xml:space="preserve">
     <value>The specified curve '{0}' or its parameters are not valid for this platform.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
index 5b241ff7afc482..43328cc42ac286 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/Resources/Strings.resx
@@ -169,9 +169,6 @@
   <data name="Cryptography_Der_Invalid_Encoding" xml:space="preserve">
     <value>ASN1 corrupted data.</value>
   </data>
-  <data name="Cryptography_HashAlgorithmNameNullOrEmpty" xml:space="preserve">
-    <value>The hash algorithm name cannot be null or empty.</value>
-  </data>
   <data name="Cryptography_InvalidECCharacteristic2Curve" xml:space="preserve">
     <value>The specified Characteristic2 curve parameters are not valid. Polynomial, A, B, G.X, G.Y, and Order are required. A, B, G.X, G.Y must be the same length, and the same length as Q.X, Q.Y and D if those are specified. Seed, Cofactor and Hash are optional. Other parameters are not allowed.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs
index d1c6fc4f9fab79..2417cacbc7a4fc 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs
@@ -58,12 +58,9 @@ public sealed class CertificateRequest
         /// <seealso cref="X500DistinguishedName(string)"/>
         public CertificateRequest(string subjectName, ECDsa key, HashAlgorithmName hashAlgorithm)
         {
-            if (subjectName == null)
-                throw new ArgumentNullException(nameof(subjectName));
-            if (key == null)
-                throw new ArgumentNullException(nameof(key));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(subjectName);
+            ArgumentNullException.ThrowIfNull(key);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             SubjectName = new X500DistinguishedName(subjectName);
 
@@ -88,12 +85,9 @@ public CertificateRequest(string subjectName, ECDsa key, HashAlgorithmName hashA
         /// </param>
         public CertificateRequest(X500DistinguishedName subjectName, ECDsa key, HashAlgorithmName hashAlgorithm)
         {
-            if (subjectName == null)
-                throw new ArgumentNullException(nameof(subjectName));
-            if (key == null)
-                throw new ArgumentNullException(nameof(key));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(subjectName);
+            ArgumentNullException.ThrowIfNull(key);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             SubjectName = subjectName;
 
@@ -122,14 +116,10 @@ public CertificateRequest(X500DistinguishedName subjectName, ECDsa key, HashAlgo
         /// <seealso cref="X500DistinguishedName(string)"/>
         public CertificateRequest(string subjectName, RSA key, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
         {
-            if (subjectName == null)
-                throw new ArgumentNullException(nameof(subjectName));
-            if (key == null)
-                throw new ArgumentNullException(nameof(key));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(subjectName);
+            ArgumentNullException.ThrowIfNull(key);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             SubjectName = new X500DistinguishedName(subjectName);
 
@@ -162,14 +152,10 @@ public CertificateRequest(
             HashAlgorithmName hashAlgorithm,
             RSASignaturePadding padding)
         {
-            if (subjectName == null)
-                throw new ArgumentNullException(nameof(subjectName));
-            if (key == null)
-                throw new ArgumentNullException(nameof(key));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(subjectName);
+            ArgumentNullException.ThrowIfNull(key);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             SubjectName = subjectName;
 
@@ -194,12 +180,9 @@ public CertificateRequest(
         /// </param>
         public CertificateRequest(X500DistinguishedName subjectName, PublicKey publicKey, HashAlgorithmName hashAlgorithm)
         {
-            if (subjectName == null)
-                throw new ArgumentNullException(nameof(subjectName));
-            if (publicKey == null)
-                throw new ArgumentNullException(nameof(publicKey));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(subjectName);
+            ArgumentNullException.ThrowIfNull(publicKey);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             SubjectName = subjectName;
             PublicKey = publicKey;
diff --git a/src/libraries/System.Security.Cryptography.X509Certificates/tests/CertificateCreation/CertificateRequestApiTests.cs b/src/libraries/System.Security.Cryptography.X509Certificates/tests/CertificateCreation/CertificateRequestApiTests.cs
index 8a80d0e116cb73..1cf2e93872ed1d 100644
--- a/src/libraries/System.Security.Cryptography.X509Certificates/tests/CertificateCreation/CertificateRequestApiTests.cs
+++ b/src/libraries/System.Security.Cryptography.X509Certificates/tests/CertificateCreation/CertificateRequestApiTests.cs
@@ -91,25 +91,28 @@ public static void CtorValidation_ECDSA_string()
         {
             string subjectName = null;
             ECDsa key = null;
-            HashAlgorithmName hashAlgorithm = default(HashAlgorithmName);
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "subjectName",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName)));
 
             subjectName = "";
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "key",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName)));
 
             key = ECDsa.Create(EccTestData.Secp384r1Data.KeyParameters);
 
             using (key)
             {
+                AssertExtensions.Throws<ArgumentNullException>(
+                    "hashAlgorithm",
+                    () => new CertificateRequest(subjectName, key, default(HashAlgorithmName)));
+
                 AssertExtensions.Throws<ArgumentException>(
                     "hashAlgorithm",
-                    () => new CertificateRequest(subjectName, key, hashAlgorithm));
+                    () => new CertificateRequest(subjectName, key, new HashAlgorithmName("")));
             }
         }
 
@@ -118,25 +121,27 @@ public static void CtorValidation_ECDSA_X500DN()
         {
             X500DistinguishedName subjectName = null;
             ECDsa key = null;
-            HashAlgorithmName hashAlgorithm = default(HashAlgorithmName);
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "subjectName",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName)));
 
             subjectName = new X500DistinguishedName("");
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "key",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName)));
 
             key = ECDsa.Create(EccTestData.Secp384r1Data.KeyParameters);
 
             using (key)
             {
+                AssertExtensions.Throws<ArgumentNullException>(
+                    "hashAlgorithm",
+                    () => new CertificateRequest(subjectName, key, default(HashAlgorithmName)));
                 AssertExtensions.Throws<ArgumentException>(
                     "hashAlgorithm",
-                    () => new CertificateRequest(subjectName, key, hashAlgorithm));
+                    () => new CertificateRequest(subjectName, key, new HashAlgorithmName("")));
             }
         }
 
@@ -145,32 +150,29 @@ public static void CtorValidation_RSA_string()
         {
             string subjectName = null;
             RSA key = null;
-            HashAlgorithmName hashAlgorithm = default(HashAlgorithmName);
             RSASignaturePadding padding = null;
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "subjectName",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName), padding));
 
             subjectName = "";
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "key",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName), padding));
 
             key = RSA.Create(TestData.RsaBigExponentParams);
 
             using (key)
             {
-                AssertExtensions.Throws<ArgumentException>(
+                AssertExtensions.Throws<ArgumentNullException>(
                     "hashAlgorithm",
-                    () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
-
-                hashAlgorithm = HashAlgorithmName.SHA256;
+                    () => new CertificateRequest(subjectName, key, default(HashAlgorithmName), padding));
 
                 AssertExtensions.Throws<ArgumentNullException>(
                     "padding",
-                    () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
+                    () => new CertificateRequest(subjectName, key, HashAlgorithmName.SHA256, padding));
             }
         }
 
@@ -179,32 +181,33 @@ public static void CtorValidation_RSA_X500DN()
         {
             X500DistinguishedName subjectName = null;
             RSA key = null;
-            HashAlgorithmName hashAlgorithm = default(HashAlgorithmName);
             RSASignaturePadding padding = null;
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "subjectName",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName), padding));
 
             subjectName = new X500DistinguishedName("");
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "key",
-                () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
+                () => new CertificateRequest(subjectName, key, default(HashAlgorithmName), padding));
 
             key = RSA.Create(TestData.RsaBigExponentParams);
 
             using (key)
             {
-                AssertExtensions.Throws<ArgumentException>(
+                AssertExtensions.Throws<ArgumentNullException>(
                     "hashAlgorithm",
-                    () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
+                    () => new CertificateRequest(subjectName, key, default(HashAlgorithmName), padding));
 
-                hashAlgorithm = HashAlgorithmName.SHA256;
+                AssertExtensions.Throws<ArgumentException>(
+                    "hashAlgorithm",
+                    () => new CertificateRequest(subjectName, key, new HashAlgorithmName(""), padding));
 
                 AssertExtensions.Throws<ArgumentNullException>(
                     "padding",
-                    () => new CertificateRequest(subjectName, key, hashAlgorithm, padding));
+                    () => new CertificateRequest(subjectName, key, HashAlgorithmName.SHA256, padding));
             }
         }
 
@@ -213,17 +216,16 @@ public static void CtorValidation_PublicKey_X500DN()
         {
             X500DistinguishedName subjectName = null;
             PublicKey publicKey = null;
-            HashAlgorithmName hashAlgorithm = default(HashAlgorithmName);
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "subjectName",
-                () => new CertificateRequest(subjectName, publicKey, hashAlgorithm));
+                () => new CertificateRequest(subjectName, publicKey, default(HashAlgorithmName)));
 
             subjectName = new X500DistinguishedName("");
 
             AssertExtensions.Throws<ArgumentNullException>(
                 "publicKey",
-                () => new CertificateRequest(subjectName, publicKey, hashAlgorithm));
+                () => new CertificateRequest(subjectName, publicKey, default(HashAlgorithmName)));
 
             using (ECDsa ecdsa = ECDsa.Create(EccTestData.Secp384r1Data.KeyParameters))
             {
@@ -231,9 +233,13 @@ public static void CtorValidation_PublicKey_X500DN()
                 publicKey = generator.PublicKey;
             }
 
+            AssertExtensions.Throws<ArgumentNullException>(
+                "hashAlgorithm",
+                () => new CertificateRequest(subjectName, publicKey, default(HashAlgorithmName)));
+
             AssertExtensions.Throws<ArgumentException>(
                 "hashAlgorithm",
-                () => new CertificateRequest(subjectName, publicKey, hashAlgorithm));
+                () => new CertificateRequest(subjectName, publicKey, new HashAlgorithmName("")));
         }
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/DSA.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/DSA.cs
index c19b7103384cc0..0990807ceed7ad 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/DSA.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/DSA.cs
@@ -127,10 +127,8 @@ public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm)
         /// </exception>
         public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -139,14 +137,12 @@ public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm, DSASignatur
 
         public virtual byte[] SignData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, offset, count, hashAlgorithm);
             return CreateSignature(hash);
@@ -195,14 +191,12 @@ public byte[] SignData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -242,10 +236,8 @@ protected virtual byte[] SignDataCore(
 
         public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, hashAlgorithm);
             return CreateSignature(hash);
@@ -274,10 +266,8 @@ public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm)
         /// </exception>
         public byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -314,16 +304,13 @@ public bool VerifyData(byte[] data, byte[] signature, HashAlgorithmName hashAlgo
 
         public virtual bool VerifyData(byte[] data, int offset, int count, byte[] signature, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, offset, count, hashAlgorithm);
             return VerifySignature(hash, signature);
@@ -374,16 +361,13 @@ public bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -392,12 +376,9 @@ public bool VerifyData(
 
         public virtual bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, hashAlgorithm);
             return VerifySignature(hash, signature);
@@ -544,8 +525,7 @@ public virtual bool TrySignData(
             HashAlgorithmName hashAlgorithm,
             out int bytesWritten)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             if (TryHashData(data, destination, hashAlgorithm, out int hashLength) &&
                 TryCreateSignature(destination.Slice(0, hashLength), destination, out bytesWritten))
@@ -589,8 +569,7 @@ public bool TrySignData(
             DSASignatureFormat signatureFormat,
             out int bytesWritten)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -634,8 +613,7 @@ public virtual bool VerifyData(
             ReadOnlySpan<byte> signature,
             HashAlgorithmName hashAlgorithm)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             return VerifyDataCore(data, signature, hashAlgorithm, DSASignatureFormat.IeeeP1363FixedFieldConcatenation);
         }
@@ -668,12 +646,9 @@ public bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -708,12 +683,9 @@ public bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -765,8 +737,7 @@ public bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -933,9 +904,6 @@ private byte[] HashSpanToArray(ReadOnlySpan<byte> data, HashAlgorithmName hashAl
         private static Exception DerivedClassMustOverride() =>
             new NotImplementedException(SR.NotSupported_SubclassOverride);
 
-        internal static Exception HashAlgorithmNameNullOrEmpty() =>
-            new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, "hashAlgorithm");
-
         public override bool TryExportEncryptedPkcs8PrivateKey(
             ReadOnlySpan<byte> passwordBytes,
             PbeParameters pbeParameters,
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDsa.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDsa.cs
index 310e7e135ea679..735230cb2a9d95 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDsa.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDsa.cs
@@ -51,14 +51,12 @@ public virtual byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm)
 
         public virtual byte[] SignData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, offset, count, hashAlgorithm);
             return SignHash(hash);
@@ -107,14 +105,12 @@ public byte[] SignData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -200,10 +196,8 @@ protected virtual byte[] SignDataCore(
         /// </exception>
         public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -233,10 +227,8 @@ public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm, DSASignatur
         /// </exception>
         public byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -349,8 +341,7 @@ public virtual bool TrySignData(
             HashAlgorithmName hashAlgorithm,
             out int bytesWritten)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             Span<byte> hashTmp = stackalloc byte[HashBufferStackSize];
             ReadOnlySpan<byte> hash = HashSpanToTmp(data, hashAlgorithm, hashTmp);
@@ -389,8 +380,7 @@ public bool TrySignData(
             DSASignatureFormat signatureFormat,
             out int bytesWritten)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -431,10 +421,8 @@ protected virtual bool TrySignDataCore(
 
         public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, hashAlgorithm);
             return SignHash(hash);
@@ -450,16 +438,13 @@ public bool VerifyData(byte[] data, byte[] signature, HashAlgorithmName hashAlgo
 
         public virtual bool VerifyData(byte[] data, int offset, int count, byte[] signature, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, offset, count, hashAlgorithm);
             return VerifyHash(hash, signature);
@@ -510,16 +495,13 @@ public bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -554,12 +536,9 @@ public bool VerifyData(
         /// </exception>
         public bool VerifyData(byte[] data, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -568,8 +547,7 @@ public bool VerifyData(byte[] data, byte[] signature, HashAlgorithmName hashAlgo
 
         public virtual bool VerifyData(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             Span<byte> hashTmp = stackalloc byte[HashBufferStackSize];
             ReadOnlySpan<byte> hash = HashSpanToTmp(data, hashAlgorithm, hashTmp);
@@ -598,8 +576,7 @@ public bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
@@ -644,12 +621,9 @@ protected virtual bool VerifyDataCore(
 
         public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             byte[] hash = HashData(data, hashAlgorithm);
             return VerifyHash(hash, signature);
@@ -683,12 +657,9 @@ public bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             DSASignatureFormat signatureFormat)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
             if (!signatureFormat.IsKnownValue())
                 throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat);
 
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/IncrementalHash.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/IncrementalHash.cs
index 55d4ee2f8294d9..23fbadceab2554 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/IncrementalHash.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/IncrementalHash.cs
@@ -319,8 +319,7 @@ public void Dispose()
         /// <exception cref="CryptographicException"><paramref name="hashAlgorithm"/> is not a known hash algorithm.</exception>
         public static IncrementalHash CreateHash(HashAlgorithmName hashAlgorithm)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             return new IncrementalHash(hashAlgorithm, HashProviderDispenser.CreateHashProvider(hashAlgorithm.Name));
         }
@@ -381,8 +380,7 @@ public static IncrementalHash CreateHMAC(HashAlgorithmName hashAlgorithm, byte[]
         [UnsupportedOSPlatform("browser")]
         public static IncrementalHash CreateHMAC(HashAlgorithmName hashAlgorithm, ReadOnlySpan<byte> key)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             return new IncrementalHash(hashAlgorithm, new HMACCommon(hashAlgorithm.Name, key, -1));
         }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSA.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSA.cs
index e5fa800517f381..da0a5aedd5b2f9 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSA.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSA.cs
@@ -168,16 +168,13 @@ public virtual byte[] SignData(
             HashAlgorithmName hashAlgorithm,
             RSASignaturePadding padding)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             byte[] hash = HashData(data, offset, count, hashAlgorithm);
             return SignHash(hash, hashAlgorithm, padding);
@@ -185,12 +182,9 @@ public virtual byte[] SignData(
 
         public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             byte[] hash = HashData(data, hashAlgorithm);
             return SignHash(hash, hashAlgorithm, padding);
@@ -198,14 +192,8 @@ public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, RSA
 
         public virtual bool TrySignData(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding, out int bytesWritten)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-            {
-                throw HashAlgorithmNameNullOrEmpty();
-            }
-            if (padding == null)
-            {
-                throw new ArgumentNullException(nameof(padding));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             if (TryHashData(data, destination, hashAlgorithm, out int hashLength) &&
                 TrySignHash(destination.Slice(0, hashLength), destination, hashAlgorithm, padding, out bytesWritten))
@@ -233,18 +221,14 @@ public virtual bool VerifyData(
             HashAlgorithmName hashAlgorithm,
             RSASignaturePadding padding)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
+            ArgumentNullException.ThrowIfNull(data);
             if (offset < 0 || offset > data.Length)
                 throw new ArgumentOutOfRangeException(nameof(offset));
             if (count < 0 || count > data.Length - offset)
                 throw new ArgumentOutOfRangeException(nameof(count));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             byte[] hash = HashData(data, offset, count, hashAlgorithm);
             return VerifyHash(hash, signature, hashAlgorithm, padding);
@@ -252,14 +236,10 @@ public virtual bool VerifyData(
 
         public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
         {
-            if (data == null)
-                throw new ArgumentNullException(nameof(data));
-            if (signature == null)
-                throw new ArgumentNullException(nameof(signature));
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw HashAlgorithmNameNullOrEmpty();
-            if (padding == null)
-                throw new ArgumentNullException(nameof(padding));
+            ArgumentNullException.ThrowIfNull(data);
+            ArgumentNullException.ThrowIfNull(signature);
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             byte[] hash = HashData(data, hashAlgorithm);
             return VerifyHash(hash, signature, hashAlgorithm, padding);
@@ -267,14 +247,8 @@ public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgo
 
         public virtual bool VerifyData(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-            {
-                throw HashAlgorithmNameNullOrEmpty();
-            }
-            if (padding == null)
-            {
-                throw new ArgumentNullException(nameof(padding));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
+            ArgumentNullException.ThrowIfNull(padding);
 
             for (int i = 256; ; i = checked(i * 2))
             {
@@ -1015,8 +989,5 @@ private static void ClearPrivateParameters(in RSAParameters rsaParameters)
 
         public override string? KeyExchangeAlgorithm => "RSA";
         public override string SignatureAlgorithm => "RSA";
-
-        private static Exception HashAlgorithmNameNullOrEmpty() =>
-            new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, "hashAlgorithm");
     }
 }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSAEncryptionPadding.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSAEncryptionPadding.cs
index cfc36cbbacf554..c31f665ad40008 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSAEncryptionPadding.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSAEncryptionPadding.cs
@@ -56,10 +56,7 @@ private RSAEncryptionPadding(RSAEncryptionPaddingMode mode, HashAlgorithmName oa
         /// </summary>
         public static RSAEncryptionPadding CreateOaep(HashAlgorithmName hashAlgorithm)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-            {
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm));
 
             return new RSAEncryptionPadding(RSAEncryptionPaddingMode.Oaep, hashAlgorithm);
         }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Rfc2898DeriveBytes.OneShot.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Rfc2898DeriveBytes.OneShot.cs
index 205bb91860c1fc..20190fd32fcd98 100644
--- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Rfc2898DeriveBytes.OneShot.cs
+++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Rfc2898DeriveBytes.OneShot.cs
@@ -329,10 +329,8 @@ private static void Pbkdf2Core(
 
         private static void ValidateHashAlgorithm(HashAlgorithmName hashAlgorithm)
         {
-            if (string.IsNullOrEmpty(hashAlgorithm.Name))
-                throw new ArgumentException(SR.Cryptography_HashAlgorithmNameNullOrEmpty, nameof(hashAlgorithm));
-
-            string hashAlgorithmName = hashAlgorithm.Name;
+            string? hashAlgorithmName = hashAlgorithm.Name;
+            ArgumentException.ThrowIfNullOrEmpty(hashAlgorithmName, nameof(hashAlgorithm));
 
             // MD5 intentionally left out.
             if (hashAlgorithmName != HashAlgorithmName.SHA1.Name &&
diff --git a/src/libraries/System.Security.Cryptography/tests/DSATests.cs b/src/libraries/System.Security.Cryptography/tests/DSATests.cs
index 66a25990bc2f86..2e3bdc2e5e768f 100644
--- a/src/libraries/System.Security.Cryptography/tests/DSATests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/DSATests.cs
@@ -55,9 +55,9 @@ public void SignData_InvalidArguments_Throws()
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("offset", () => wrapperDsa.SignData(new byte[1], 2, 0, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => wrapperDsa.SignData(new byte[1], 0, -1, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => wrapperDsa.SignData(new byte[1], 0, 2, HashAlgorithmName.SHA1));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.SignData(new byte[1], new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => wrapperDsa.SignData(new byte[1], new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.SignData(new byte[1], new HashAlgorithmName("")));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.SignData(new MemoryStream(new byte[1]), new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => wrapperDsa.SignData(new MemoryStream(new byte[1]), new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.SignData(new MemoryStream(new byte[1]), new HashAlgorithmName("")));
             }
         }
@@ -74,7 +74,7 @@ public void TrySignData_UsesTryHashDataAndTryCreateSignature()
                 byte[] initialSig = wrapperDsa.SignData(input, HashAlgorithmName.SHA1);
                 byte[] actualSig = new byte[initialSig.Length];
 
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.TrySignData(new byte[1], new byte[1], new HashAlgorithmName(null), out int _));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => wrapperDsa.TrySignData(new byte[1], new byte[1], new HashAlgorithmName(null), out int _));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.TrySignData(new byte[1], new byte[1], new HashAlgorithmName(""), out int _));
 
                 Assert.False(wrapperDsa.TrySignData(input, new Span<byte>(actualSig, 0, 1), HashAlgorithmName.SHA1, out bytesWritten));
@@ -102,7 +102,7 @@ public void VerifyData_Array_UsesHashDataAndVerifySignature()
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => wrapperDsa.VerifyData(new byte[1], 0, -1, null, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => wrapperDsa.VerifyData(new byte[1], 0, 2, null, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentNullException>("signature", () => wrapperDsa.VerifyData(new byte[1], 0, 1, null, HashAlgorithmName.SHA1));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.VerifyData(new byte[1], new byte[1], new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => wrapperDsa.VerifyData(new byte[1], new byte[1], new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.VerifyData(new byte[1], new byte[1], new HashAlgorithmName("")));
 
                 byte[] signature = wrapperDsa.SignData(input, HashAlgorithmName.SHA1);
@@ -121,7 +121,7 @@ public void VerifyData_Stream_UsesHashDataAndVerifySignature()
             {
                 AssertExtensions.Throws<ArgumentNullException>("data", () => wrapperDsa.VerifyData((Stream)null, null, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentNullException>("signature", () => wrapperDsa.VerifyData(new MemoryStream(new byte[1]), null, HashAlgorithmName.SHA1));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.VerifyData(new MemoryStream(new byte[1]), new byte[1], new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => wrapperDsa.VerifyData(new MemoryStream(new byte[1]), new byte[1], new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.VerifyData(new MemoryStream(new byte[1]), new byte[1], new HashAlgorithmName("")));
 
                 byte[] signature = wrapperDsa.SignData(new MemoryStream(input), HashAlgorithmName.SHA1);
@@ -138,7 +138,7 @@ public void VerifyData_Span_UsesTryHashDataAndVerifySignature()
 
             using (var wrapperDsa = new OverrideAbstractDSA(DSA.Create(1024)))
             {
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.VerifyData((Span<byte>)new byte[1], new byte[1], new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => wrapperDsa.VerifyData((Span<byte>)new byte[1], new byte[1], new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => wrapperDsa.VerifyData((Span<byte>)new byte[1], new byte[1], new HashAlgorithmName("")));
 
                 byte[] signature = wrapperDsa.SignData(input, HashAlgorithmName.SHA1);
diff --git a/src/libraries/System.Security.Cryptography/tests/ECDsaTests.cs b/src/libraries/System.Security.Cryptography/tests/ECDsaTests.cs
index 0abd2570bd9548..7851ef4f7b4fe3 100644
--- a/src/libraries/System.Security.Cryptography/tests/ECDsaTests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/ECDsaTests.cs
@@ -64,7 +64,7 @@ public void Array_SignData_VerifyData_UsesHashDataAndSignHashAndVerifyHash()
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("offset", () => ecdsa.SignData(new byte[1], 2, 0, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.SignData(new byte[1], 0, -1, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.SignData(new byte[1], 0, 2, HashAlgorithmName.SHA1));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new byte[1], 0, 1, new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.SignData(new byte[1], 0, 1, new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new byte[1], 0, 1, new HashAlgorithmName("")));
 
                 AssertExtensions.Throws<ArgumentNullException>("data", () => ecdsa.VerifyData((byte[])null, null, HashAlgorithmName.SHA1));
@@ -74,7 +74,7 @@ public void Array_SignData_VerifyData_UsesHashDataAndSignHashAndVerifyHash()
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.VerifyData(new byte[1], 0, -1, null, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => ecdsa.VerifyData(new byte[1], 0, 2, null, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentNullException>("signature", () => ecdsa.VerifyData(new byte[1], 0, 1, null, HashAlgorithmName.SHA1));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[1], 0, 1, new byte[1], new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[1], 0, 1, new byte[1], new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new byte[1], 0, 1, new byte[1], new HashAlgorithmName("")));
 
                 var input = new byte[1024];
@@ -95,12 +95,12 @@ public void Stream_SignData_VerifyData_UsesHashDataAndSignHashAndVerifyHash()
             using (var ecdsa = new OverrideAbstractECDsa(ECDsaFactory.Create()))
             {
                 AssertExtensions.Throws<ArgumentNullException>("data", () => ecdsa.SignData((Stream)null, HashAlgorithmName.SHA1));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new MemoryStream(new byte[1]), new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.SignData(new MemoryStream(new byte[1]), new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.SignData(new MemoryStream(new byte[1]), new HashAlgorithmName("")));
 
                 AssertExtensions.Throws<ArgumentNullException>("data", () => ecdsa.VerifyData((Stream)null, null, HashAlgorithmName.SHA1));
                 AssertExtensions.Throws<ArgumentNullException>("signature", () => ecdsa.VerifyData(new MemoryStream(new byte[1]), null, HashAlgorithmName.SHA1));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new MemoryStream(new byte[1]), new byte[1], new HashAlgorithmName(null)));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.VerifyData(new MemoryStream(new byte[1]), new byte[1], new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData(new MemoryStream(new byte[1]), new byte[1], new HashAlgorithmName("")));
 
                 var input = new byte[1024];
@@ -120,10 +120,10 @@ public void Span_TrySignData_VerifyData_UsesTryHashDataAndTrySignHashAndTryVerif
         {
             using (var ecdsa = new OverrideAbstractECDsa(ECDsaFactory.Create()))
             {
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.TrySignData(new byte[1], new byte[1], new HashAlgorithmName(null), out int bytesWritten));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.TrySignData(new byte[1], new byte[1], new HashAlgorithmName(null), out int bytesWritten));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.TrySignData(new byte[1], new byte[1], new HashAlgorithmName(""), out int bytesWritten));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => ecdsa.VerifyData((ReadOnlySpan<byte>)new byte[1], new byte[1], new HashAlgorithmName(null)));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData((ReadOnlySpan<byte>)new byte[1], new byte[1], new HashAlgorithmName("")));
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => ecdsa.VerifyData((ReadOnlySpan<byte>)new byte[1], new byte[1], new HashAlgorithmName(null)));
 
                 var input = new byte[1024];
                 Random.Shared.NextBytes(input);
diff --git a/src/libraries/System.Security.Cryptography/tests/IncrementalHashTests.cs b/src/libraries/System.Security.Cryptography/tests/IncrementalHashTests.cs
index d5acc5b27aa435..e1a31bd49dc935 100644
--- a/src/libraries/System.Security.Cryptography/tests/IncrementalHashTests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/IncrementalHashTests.cs
@@ -42,13 +42,13 @@ public static IEnumerable<object[]> GetHMACs()
         [Fact]
         public static void InvalidArguments_Throw()
         {
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => IncrementalHash.CreateHash(new HashAlgorithmName(null)));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => IncrementalHash.CreateHash(new HashAlgorithmName(null)));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => IncrementalHash.CreateHash(new HashAlgorithmName("")));
 
             if (PlatformDetection.IsNotBrowser)
             {
                 // HMAC is not supported on Browser
-                AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => IncrementalHash.CreateHMAC(new HashAlgorithmName(null), new byte[1]));
+                AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => IncrementalHash.CreateHMAC(new HashAlgorithmName(null), new byte[1]));
                 AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => IncrementalHash.CreateHMAC(new HashAlgorithmName(""), new byte[1]));
 
                 AssertExtensions.Throws<ArgumentNullException>("key", () => IncrementalHash.CreateHMAC(HashAlgorithmName.SHA512, null));
diff --git a/src/libraries/System.Security.Cryptography/tests/RSATests.cs b/src/libraries/System.Security.Cryptography/tests/RSATests.cs
index 9decadbc179f7e..17911da7f1b592 100644
--- a/src/libraries/System.Security.Cryptography/tests/RSATests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/RSATests.cs
@@ -145,7 +145,7 @@ public void SignDataArray_UsesHashDataAndSignHash()
             AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => rsa.SignData(new byte[1], 0, -1, HashAlgorithmName.SHA256, null));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => rsa.SignData(new byte[1], 0, 2, HashAlgorithmName.SHA256, null));
 
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => rsa.SignData(new byte[1], 0, 1, new HashAlgorithmName(null), null));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => rsa.SignData(new byte[1], 0, 1, new HashAlgorithmName(null), null));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => rsa.SignData(new byte[1], 0, 1, new HashAlgorithmName(""), null));
 
             AssertExtensions.Throws<ArgumentNullException>("padding", () => rsa.SignData(new byte[1], 0, 1, new HashAlgorithmName("abc"), null));
@@ -163,7 +163,7 @@ public void SignDataStream_UsesHashDataAndSignHash()
 
             AssertExtensions.Throws<ArgumentNullException>("data", () => rsa.SignData((Stream)null, HashAlgorithmName.SHA256, null));
 
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => rsa.SignData(Stream.Null, new HashAlgorithmName(null), null));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => rsa.SignData(Stream.Null, new HashAlgorithmName(null), null));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => rsa.SignData(Stream.Null, new HashAlgorithmName(""), null));
 
             AssertExtensions.Throws<ArgumentNullException>("padding", () => rsa.SignData(Stream.Null, new HashAlgorithmName("abc"), null));
@@ -182,7 +182,7 @@ public void VerifyDataStream_UsesHashDataAndVerifyHash()
 
             AssertExtensions.Throws<ArgumentNullException>("signature", () => rsa.VerifyData(Stream.Null, null, HashAlgorithmName.SHA256, null));
 
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => rsa.VerifyData(Stream.Null, new byte[1], new HashAlgorithmName(null), null));
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () => rsa.VerifyData(Stream.Null, new byte[1], new HashAlgorithmName(null), null));
             AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () => rsa.VerifyData(Stream.Null, new byte[1], new HashAlgorithmName(""), null));
 
             AssertExtensions.Throws<ArgumentNullException>("padding", () => rsa.VerifyData(Stream.Null, new byte[1], new HashAlgorithmName("abc"), null));
diff --git a/src/libraries/System.Security.Cryptography/tests/Rfc2898OneShotTests.cs b/src/libraries/System.Security.Cryptography/tests/Rfc2898OneShotTests.cs
index 3376d711779bf2..cd92dc99b57eaa 100644
--- a/src/libraries/System.Security.Cryptography/tests/Rfc2898OneShotTests.cs
+++ b/src/libraries/System.Security.Cryptography/tests/Rfc2898OneShotTests.cs
@@ -75,10 +75,14 @@ public static void Pbkdf2_PasswordBytes_BogusHash()
         [Fact]
         public static void Pbkdf2_PasswordBytes_NullHashName()
         {
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () =>
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () =>
                 Rfc2898DeriveBytes.Pbkdf2(
                     s_passwordBytes, s_salt, iterations: 1, default(HashAlgorithmName), s_extractLength)
             );
+            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () =>
+                Rfc2898DeriveBytes.Pbkdf2(
+                    s_passwordBytes, s_salt, iterations: 1, new HashAlgorithmName(""), s_extractLength)
+            );
         }
 
         [Fact]
@@ -147,10 +151,14 @@ public static void Pbkdf2_PasswordString_BogusHash()
         [Fact]
         public static void Pbkdf2_PasswordString_NullHashName()
         {
-            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () =>
+            AssertExtensions.Throws<ArgumentNullException>("hashAlgorithm", () =>
                 Rfc2898DeriveBytes.Pbkdf2(
                     Password, s_salt, iterations: 1, default(HashAlgorithmName), s_extractLength)
             );
+            AssertExtensions.Throws<ArgumentException>("hashAlgorithm", () =>
+                Rfc2898DeriveBytes.Pbkdf2(
+                    Password, s_salt, iterations: 1, new HashAlgorithmName(""), s_extractLength)
+            );
         }
 
         [Fact]
diff --git a/src/libraries/System.Security.Principal.Windows/src/Resources/Strings.resx b/src/libraries/System.Security.Principal.Windows/src/Resources/Strings.resx
index adbd9d11a0a563..ac766cc5e7e886 100644
--- a/src/libraries/System.Security.Principal.Windows/src/Resources/Strings.resx
+++ b/src/libraries/System.Security.Principal.Windows/src/Resources/Strings.resx
@@ -84,9 +84,6 @@
   <data name="ArgumentOutOfRange_NeedNonNegNum" xml:space="preserve">
     <value>Non-negative number required.</value>
   </data>
-  <data name="Argument_StringZeroLength" xml:space="preserve">
-    <value>String cannot be of zero length.</value>
-  </data>
   <data name="IdentityReference_AccountNameTooLong" xml:space="preserve">
     <value>Account name is too long.</value>
   </data>
@@ -120,4 +117,4 @@
   <data name="PlatformNotSupported_Principal" xml:space="preserve">
     <value>Windows Principal functionality is not supported on this platform.</value>
   </data>
-</root>
\ No newline at end of file
+</root>
diff --git a/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/NTAccount.cs b/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/NTAccount.cs
index 82475e99b62fab..1513f00ceb6421 100644
--- a/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/NTAccount.cs
+++ b/src/libraries/System.Security.Principal.Windows/src/System/Security/Principal/NTAccount.cs
@@ -33,15 +33,7 @@ public sealed class NTAccount : IdentityReference
 
         public NTAccount(string domainName, string accountName)
         {
-            if (accountName == null)
-            {
-                throw new ArgumentNullException(nameof(accountName));
-            }
-
-            if (accountName.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_StringZeroLength, nameof(accountName));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(accountName);
 
             if (accountName.Length > MaximumAccountNameLength)
             {
@@ -65,15 +57,7 @@ public NTAccount(string domainName, string accountName)
 
         public NTAccount(string name)
         {
-            if (name == null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (name.Length == 0)
-            {
-                throw new ArgumentException(SR.Argument_StringZeroLength, nameof(name));
-            }
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             if (name.Length > (MaximumDomainNameLength + 1 /* '\' */ + MaximumAccountNameLength))
             {
diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompilationInfo.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompilationInfo.cs
index 850846cf288d3c..dba088035ce8b6 100644
--- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompilationInfo.cs
+++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexCompilationInfo.cs
@@ -47,16 +47,7 @@ public string Name
             [MemberNotNull(nameof(_name))]
             set
             {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(Name));
-                }
-
-                if (value.Length == 0)
-                {
-                    throw new ArgumentException(SR.Format(SR.InvalidEmptyArgument, nameof(Name)), nameof(Name));
-                }
-
+                ArgumentException.ThrowIfNullOrEmpty(value, nameof(Name));
                 _name = value;
             }
         }
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.Mono.cs
index 919015e8567e39..b66f7d9b897045 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.Mono.cs
@@ -258,10 +258,7 @@ public static AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyB
 
         public ModuleBuilder DefineDynamicModule(string name)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException("Empty name is not legal.", nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if (name[0] == '\0')
                 throw new ArgumentException(SR.Argument_InvalidName, nameof(name));
 
@@ -273,15 +270,13 @@ public ModuleBuilder DefineDynamicModule(string name)
 
         public ModuleBuilder? GetDynamicModule(string name)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException("Empty name is not legal.", nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             if (modules != null)
                 for (int i = 0; i < modules.Length; ++i)
                     if (modules[i].name == name)
                         return modules[i];
+
             return null;
         }
 
@@ -326,10 +321,7 @@ internal static Type MakeGenericType(Type gtd, Type[] typeArguments) =>
         [RequiresUnreferencedCode("Types might be removed")]
         public override Type? GetType(string name, bool throwOnError, bool ignoreCase)
         {
-            if (name == null)
-                throw new ArgumentNullException(name);
-            if (name.Length == 0)
-                throw new ArgumentException("Name cannot be empty", nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             Type res = InternalGetType(null, name, throwOnError, ignoreCase);
             if (res is TypeBuilder)
@@ -343,10 +335,7 @@ internal static Type MakeGenericType(Type gtd, Type[] typeArguments) =>
 
         public override Module? GetModule(string name)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException("Name can't be empty");
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             if (modules == null)
                 return null;
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs
index 1095954e87b413..1115440ac1f687 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.Mono.cs
@@ -148,10 +148,7 @@ public FieldBuilder DefineUninitializedData(string name, int size, FieldAttribut
             Justification = "Reflection.Emit is not subject to trimming")]
         private FieldBuilder DefineDataImpl(string name, int size, FieldAttributes attributes)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException("name cannot be empty", nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if (global_type_created != null)
                 throw new InvalidOperationException("global fields already created");
             if ((size <= 0) || (size >= 0x3f0000))
@@ -408,10 +405,7 @@ public EnumBuilder DefineEnum(string name, TypeAttributes visibility, Type under
         [ComVisible(true)]
         public override Type? GetType(string className, bool throwOnError, bool ignoreCase)
         {
-            if (className == null)
-                throw new ArgumentNullException(nameof(className));
-            if (className.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(className));
+            ArgumentException.ThrowIfNullOrEmpty(className);
 
             TypeBuilder? result = null;
 
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
index e29d47602e84e2..b2ce581c3e5dde 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.Mono.cs
@@ -408,8 +408,7 @@ private TypeBuilder DefineNestedType(string name, TypeAttributes attr, [Dynamica
             {
                 foreach (Type iface in interfaces)
                 {
-                    if (iface == null)
-                        throw new ArgumentNullException(nameof(interfaces));
+                    ArgumentNullException.ThrowIfNull(iface, nameof(interfaces));
                     if (iface.IsByRef)
                         throw new ArgumentException(nameof(interfaces));
                 }
@@ -1593,10 +1592,7 @@ public FieldBuilder DefineInitializedData(string name, byte[] data, FieldAttribu
 
         public FieldBuilder DefineUninitializedData(string name, int size, FieldAttributes attributes)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException("Empty name is not legal", nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if ((size <= 0) || (size > 0x3f0000))
                 throw new ArgumentException("Data size must be > 0 and < 0x3f0000");
             check_not_created();
@@ -1698,9 +1694,8 @@ private void check_created()
 
         private static void check_name(string argName, string name)
         {
-            if (name == null)
-                throw new ArgumentNullException(argName);
-            if (name.Length == 0 || name[0] == ((char)0))
+            ArgumentException.ThrowIfNullOrEmpty(name, argName);
+            if (name[0] == '\0')
                 throw new ArgumentException(SR.Argument_EmptyName, argName);
         }
 
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs
index 5fbe196a1ab081..c1d33f9e061f4d 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs
@@ -228,10 +228,8 @@ private static void AddPublicNestedTypes(Type type, List<Type> types, List<Excep
 
         public override ManifestResourceInfo? GetManifestResourceInfo(string resourceName)
         {
-            if (resourceName == null)
-                throw new ArgumentNullException(nameof(resourceName));
-            if (resourceName.Length == 0)
-                throw new ArgumentException("String cannot have zero length.");
+            ArgumentException.ThrowIfNullOrEmpty(resourceName);
+
             ManifestResourceInfo result = new ManifestResourceInfo(null, null, 0);
             var this_assembly = this;
             bool found = GetManifestResourceInfoInternal(new QCallAssembly(ref this_assembly), resourceName, result);
@@ -243,12 +241,7 @@ private static void AddPublicNestedTypes(Type type, List<Type> types, List<Excep
 
         public override Stream? GetManifestResourceStream(string name)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-
-            if (name.Length == 0)
-                throw new ArgumentException("String cannot have zero length.",
-                    nameof(name));
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             unsafe
             {
@@ -292,11 +285,7 @@ public override AssemblyName GetName(bool copiedName)
         [RequiresUnreferencedCode("Types might be removed")]
         public override Type GetType(string name, bool throwOnError, bool ignoreCase)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-
-            if (name.Length == 0)
-                throw new ArgumentException("Name cannot be empty");
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             return InternalGetType(null, name, throwOnError, ignoreCase);
         }
@@ -323,10 +312,7 @@ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
 
         public override Module? GetModule(string name)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name));
-            if (name.Length == 0)
-                throw new ArgumentException("Name can't be empty");
+            ArgumentException.ThrowIfNullOrEmpty(name);
 
             Module[] modules = GetModules(true);
             foreach (Module module in modules)
@@ -450,10 +436,7 @@ public override Assembly GetSatelliteAssembly(CultureInfo culture, Version? vers
         [RequiresAssemblyFiles(ThrowingMessageInRAF)]
         public override FileStream? GetFile(string name)
         {
-            if (name == null)
-                throw new ArgumentNullException(nameof(name), SR.ArgumentNull_FileName);
-            if (name.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyFileName);
+            ArgumentException.ThrowIfNullOrEmpty(name);
             if (Location.Length == 0)
             {
                 // Throw if the assembly was loaded from memory, indicated by Location returning an empty string
diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs
index 11605dc0c9d0b1..f7c6ffb43683e8 100644
--- a/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs
+++ b/src/mono/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs
@@ -207,10 +207,7 @@ void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
         public override
         Type GetType(string className, bool throwOnError, bool ignoreCase)
         {
-            if (className == null)
-                throw new ArgumentNullException(nameof(className));
-            if (className.Length == 0)
-                throw new ArgumentException("Type name can't be empty");
+            ArgumentException.ThrowIfNullOrEmpty(className);
             return assembly.InternalGetType(this, className, throwOnError, ignoreCase);
         }
 

From d06d9c92ca6601eb4170015d3fb2182ecac54388 Mon Sep 17 00:00:00 2001
From: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
Date: Fri, 28 Jan 2022 22:48:30 +0300
Subject: [PATCH 152/161] Commutative morph optimizations (#64122)

* Optimize order of morphing

"fgMorphCommutative" exposes information to the later
transforms that make them more precise.

For example, "MUL(MUL(X, CONST1), CONST2)" is now morphed
properly into a single "mul" instead of one "mul" plus a shift
and lea in case "CONST2" was a viable candidate for "mulshift".

Another example is how "fgMorphCommutative" can end up with an
"ADD(X, 0)" that was only being discarded in lowering.

* Fold (x + 0) => 0 for LONGs on 32 bit

* Enable one opt outside global morph

No reason not to. Just a few diffs.

* Disable mulshift on ARM/64

No LEAs - no point.
---
 src/coreclr/jit/compiler.h   |  6 ----
 src/coreclr/jit/compiler.hpp | 16 ---------
 src/coreclr/jit/morph.cpp    | 66 +++++++++++++++++++++---------------
 3 files changed, 39 insertions(+), 49 deletions(-)

diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
index 3f423e8e38f1f6..967d27eac4703b 100644
--- a/src/coreclr/jit/compiler.h
+++ b/src/coreclr/jit/compiler.h
@@ -7122,12 +7122,6 @@ class Compiler
 
     bool optNarrowTree(GenTree* tree, var_types srct, var_types dstt, ValueNumPair vnpNarrow, bool doit);
 
-    /**************************************************************************
-     *                       Optimization conditions
-     *************************************************************************/
-
-    bool optAvoidIntMult(void);
-
 protected:
     //  The following is the upper limit on how many expressions we'll keep track
     //  of for the CSE analysis.
diff --git a/src/coreclr/jit/compiler.hpp b/src/coreclr/jit/compiler.hpp
index fa6863bef0d2d8..f03ecd43f77025 100644
--- a/src/coreclr/jit/compiler.hpp
+++ b/src/coreclr/jit/compiler.hpp
@@ -3578,22 +3578,6 @@ inline bool Compiler::LoopDsc::lpArrLenLimit(Compiler* comp, ArrIndex* index) co
     return false;
 }
 
-/*
-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-XX                                                                           XX
-XX                Optimization activation rules                              XX
-XX                                                                           XX
-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-*/
-
-// should we try to replace integer multiplication with lea/add/shift sequences?
-inline bool Compiler::optAvoidIntMult(void)
-{
-    return (compCodeOpt() != SMALL_CODE);
-}
-
 /*
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp
index e7a3db4e80afd2..f07fe3ca9ed02b 100644
--- a/src/coreclr/jit/morph.cpp
+++ b/src/coreclr/jit/morph.cpp
@@ -13435,28 +13435,6 @@ GenTree* Compiler::fgOptimizeCommutativeArithmetic(GenTreeOp* tree)
         std::swap(tree->gtOp1, tree->gtOp2);
     }
 
-    if (!optValnumCSE_phase)
-    {
-        GenTree* optimizedTree = nullptr;
-        if (tree->OperIs(GT_ADD))
-        {
-            optimizedTree = fgOptimizeAddition(tree);
-        }
-        else if (tree->OperIs(GT_MUL))
-        {
-            optimizedTree = fgOptimizeMultiply(tree);
-        }
-        else if (tree->OperIs(GT_AND))
-        {
-            optimizedTree = fgOptimizeBitwiseAnd(tree);
-        }
-
-        if (optimizedTree != nullptr)
-        {
-            return optimizedTree;
-        }
-    }
-
     if (fgOperIsBitwiseRotationRoot(tree->OperGet()))
     {
         GenTree* rotationTree = fgRecognizeAndMorphBitwiseRotation(tree);
@@ -13477,7 +13455,36 @@ GenTree* Compiler::fgOptimizeCommutativeArithmetic(GenTreeOp* tree)
 
     if (varTypeIsIntegralOrI(tree))
     {
+        genTreeOps oldTreeOper   = tree->OperGet();
         GenTreeOp* optimizedTree = fgMorphCommutative(tree->AsOp());
+        if (optimizedTree != nullptr)
+        {
+            if (!optimizedTree->OperIs(oldTreeOper))
+            {
+                // "optimizedTree" could end up being a COMMA.
+                return optimizedTree;
+            }
+
+            tree = optimizedTree;
+        }
+    }
+
+    if (!optValnumCSE_phase)
+    {
+        GenTree* optimizedTree = nullptr;
+        if (tree->OperIs(GT_ADD))
+        {
+            optimizedTree = fgOptimizeAddition(tree);
+        }
+        else if (tree->OperIs(GT_MUL))
+        {
+            optimizedTree = fgOptimizeMultiply(tree);
+        }
+        else if (tree->OperIs(GT_AND))
+        {
+            optimizedTree = fgOptimizeBitwiseAnd(tree);
+        }
+
         if (optimizedTree != nullptr)
         {
             return optimizedTree;
@@ -13529,8 +13536,7 @@ GenTree* Compiler::fgOptimizeAddition(GenTreeOp* add)
 
     // Fold (x + 0) - given it won't change the tree type to TYP_REF.
     // TODO-Bug: this code will lose the GC-ness of a tree like "native int + byref(0)".
-    if (op2->IsCnsIntOrI() && (op2->AsIntCon()->IconValue() == 0) &&
-        ((add->TypeGet() == op1->TypeGet()) || !op1->TypeIs(TYP_REF)))
+    if (op2->IsIntegralConst(0) && ((add->TypeGet() == op1->TypeGet()) || !op1->TypeIs(TYP_REF)))
     {
         if (op2->IsCnsIntOrI() && (op2->AsIntCon()->gtFieldSeq != nullptr) &&
             (op2->AsIntCon()->gtFieldSeq != FieldSeqStore::NotAField()))
@@ -13544,9 +13550,8 @@ GenTree* Compiler::fgOptimizeAddition(GenTreeOp* add)
         return op1;
     }
 
-    // TODO-CQ: this transform preserves VNs and can be enabled outside global morph.
     // Note that these transformations are legal for floating-point ADDs as well.
-    if (opts.OptimizationEnabled() && fgGlobalMorph)
+    if (opts.OptimizationEnabled())
     {
         // - a + b = > b - a
         // ADD((NEG(a), b) => SUB(b, a)
@@ -13655,6 +13660,13 @@ GenTree* Compiler::fgOptimizeMultiply(GenTreeOp* mul)
             return mul;
         }
 
+#ifdef TARGET_XARCH
+        // Should we try to replace integer multiplication with lea/add/shift sequences?
+        bool mulShiftOpt = compCodeOpt() != SMALL_CODE;
+#else  // !TARGET_XARCH
+        bool mulShiftOpt = false;
+#endif // !TARGET_XARCH
+
         size_t abs_mult      = (mult >= 0) ? mult : -mult;
         size_t lowestBit     = genFindLowestBit(abs_mult);
         bool   changeToShift = false;
@@ -13697,7 +13709,7 @@ GenTree* Compiler::fgOptimizeMultiply(GenTreeOp* mul)
             op2->AsIntConCommon()->SetIconValue(genLog2(abs_mult));
             changeToShift = true;
         }
-        else if ((lowestBit > 1) && jitIsScaleIndexMul(lowestBit) && optAvoidIntMult())
+        else if (mulShiftOpt && (lowestBit > 1) && jitIsScaleIndexMul(lowestBit))
         {
             int     shift  = genLog2(lowestBit);
             ssize_t factor = abs_mult >> shift;

From 315fb41e7d75f3103a50aa394e2698baf5e56252 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Fri, 28 Jan 2022 15:04:30 -0500
Subject: [PATCH 153/161] Remove pinning from StringBuilder (#64405)

Switch from pointers to refs to avoid pinning the inputs.

As part of this, I also consolidated the fast-path that was there specifically for string inputs to also apply to span inputs, char arrays, pointers, etc.
---
 .../src/System/Text/StringBuilder.cs          | 408 +++++++-----------
 1 file changed, 164 insertions(+), 244 deletions(-)

diff --git a/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs b/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs
index 9b6eb47408c485..8a8d6a93b57948 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs
@@ -408,14 +408,8 @@ public string ToString(int startIndex, int length)
 
             AssertInvariants();
             string result = string.FastAllocateString(length);
-            unsafe
-            {
-                fixed (char* destinationPtr = result)
-                {
-                    this.CopyTo(startIndex, new Span<char>(destinationPtr, length), length);
-                    return result;
-                }
-            }
+            CopyTo(startIndex, new Span<char>(ref result.GetRawStringData(), result.Length), result.Length);
+            return result;
         }
 
         public StringBuilder Clear()
@@ -639,7 +633,7 @@ internal ChunkEnumerator(StringBuilder stringBuilder)
                 // are a linked list with each chunk pointing to its PREDECESSOR, walking
                 // the list FORWARD is not efficient.   If there are few chunks (< 8) we
                 // simply scan from the start each time, and tolerate the N*N behavior.
-                // However above this size, we allocate an array to hold pointers to all
+                // However above this size, we allocate an array to hold reference to all
                 // the chunks and we can be efficient for large N.
                 int chunkCount = ChunkCount(stringBuilder);
                 if (8 < chunkCount)
@@ -771,19 +765,12 @@ public StringBuilder Append(char[]? value, int startIndex, int charCount)
                 throw new ArgumentOutOfRangeException(nameof(charCount), SR.ArgumentOutOfRange_Index);
             }
 
-            if (charCount == 0)
+            if (charCount != 0)
             {
-                return this;
+                Append(ref value[startIndex], charCount);
             }
 
-            unsafe
-            {
-                fixed (char* valueChars = &value[startIndex])
-                {
-                    Append(valueChars, charCount);
-                    return this;
-                }
-            }
+            return this;
         }
 
         /// <summary>
@@ -792,58 +779,14 @@ public StringBuilder Append(char[]? value, int startIndex, int charCount)
         /// <param name="value">The string to append.</param>
         public StringBuilder Append(string? value)
         {
-            if (value != null)
+            if (value is not null)
             {
-                // We could have just called AppendHelper here; this is a hand-specialization of that code.
-                char[] chunkChars = m_ChunkChars;
-                int chunkLength = m_ChunkLength;
-                int valueLen = value.Length;
-
-                if (((uint)chunkLength + (uint)valueLen) < (uint)chunkChars.Length) // Use strictly < to avoid issues if count == 0, newIndex == length
-                {
-                    if (valueLen <= 2)
-                    {
-                        if (valueLen > 0)
-                        {
-                            chunkChars[chunkLength] = value[0];
-                        }
-                        if (valueLen > 1)
-                        {
-                            chunkChars[chunkLength + 1] = value[1];
-                        }
-                    }
-                    else
-                    {
-                        Buffer.Memmove(
-                            ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength),
-                            ref value.GetRawStringData(),
-                            (nuint)valueLen);
-                    }
-
-                    m_ChunkLength = chunkLength + valueLen;
-                }
-                else
-                {
-                    AppendHelper(value);
-                }
+                Append(valueCount: value.Length, value: ref value.GetRawStringData());
             }
 
             return this;
         }
 
-        // We put this fixed in its own helper to avoid the cost of zero-initing `valueChars` in the
-        // case we don't actually use it.
-        private void AppendHelper(string value)
-        {
-            unsafe
-            {
-                fixed (char* valueChars = value)
-                {
-                    Append(valueChars, value.Length);
-                }
-            }
-        }
-
         /// <summary>
         /// Appends part of a string to the end of this builder.
         /// </summary>
@@ -870,24 +813,17 @@ public StringBuilder Append(string? value, int startIndex, int count)
                 throw new ArgumentNullException(nameof(value));
             }
 
-            if (count == 0)
-            {
-                return this;
-            }
-
-            if (startIndex > value.Length - count)
-            {
-                throw new ArgumentOutOfRangeException(nameof(startIndex), SR.ArgumentOutOfRange_Index);
-            }
-
-            unsafe
+            if (count != 0)
             {
-                fixed (char* valueChars = value)
+                if (startIndex > value.Length - count)
                 {
-                    Append(valueChars + startIndex, count);
-                    return this;
+                    throw new ArgumentOutOfRangeException(nameof(startIndex), SR.ArgumentOutOfRange_Index);
                 }
+
+                Append(ref Unsafe.Add(ref value.GetRawStringData(), startIndex), count);
             }
+
+            return this;
         }
 
         public StringBuilder Append(StringBuilder? value)
@@ -1073,19 +1009,14 @@ public StringBuilder Insert(int index, string? value, int count)
             Debug.Assert(insertingChars + this.Length < int.MaxValue);
 
             MakeRoom(index, (int)insertingChars, out StringBuilder chunk, out int indexInChunk, false);
-            unsafe
-            {
-                fixed (char* valuePtr = value)
-                {
-                    while (count > 0)
-                    {
-                        ReplaceInPlaceAtChunk(ref chunk!, ref indexInChunk, valuePtr, value.Length);
-                        --count;
-                    }
 
-                    return this;
-                }
+            while (count > 0)
+            {
+                ReplaceInPlaceAtChunk(ref chunk!, ref indexInChunk, ref value.GetRawStringData(), value.Length);
+                --count;
             }
+
+            return this;
         }
 
         /// <summary>
@@ -1203,31 +1134,17 @@ internal StringBuilder AppendSpanFormattable<T>(T value, string? format, IFormat
 
         public StringBuilder Append(char[]? value)
         {
-            if (value?.Length > 0)
+            if (value is not null)
             {
-                unsafe
-                {
-                    fixed (char* valueChars = &value[0])
-                    {
-                        Append(valueChars, value.Length);
-                    }
-                }
+                Append(ref MemoryMarshal.GetArrayDataReference(value), value.Length);
             }
+
             return this;
         }
 
         public StringBuilder Append(ReadOnlySpan<char> value)
         {
-            if (value.Length > 0)
-            {
-                unsafe
-                {
-                    fixed (char* valueChars = &MemoryMarshal.GetReference(value))
-                    {
-                        Append(valueChars, value.Length);
-                    }
-                }
-            }
+            Append(ref MemoryMarshal.GetReference(value), value.Length);
             return this;
         }
 
@@ -1257,51 +1174,42 @@ public StringBuilder Append(ReadOnlySpan<char> value)
 
         #region AppendJoin
 
-        public unsafe StringBuilder AppendJoin(string? separator, params object?[] values)
+        public StringBuilder AppendJoin(string? separator, params object?[] values)
         {
             separator ??= string.Empty;
-            fixed (char* pSeparator = separator)
-            {
-                return AppendJoinCore(pSeparator, separator.Length, values);
-            }
+            return AppendJoinCore(ref separator.GetRawStringData(), separator.Length, values);
         }
 
-        public unsafe StringBuilder AppendJoin<T>(string? separator, IEnumerable<T> values)
+        public StringBuilder AppendJoin<T>(string? separator, IEnumerable<T> values)
         {
             separator ??= string.Empty;
-            fixed (char* pSeparator = separator)
-            {
-                return AppendJoinCore(pSeparator, separator.Length, values);
-            }
+            return AppendJoinCore(ref separator.GetRawStringData(), separator.Length, values);
         }
 
-        public unsafe StringBuilder AppendJoin(string? separator, params string?[] values)
+        public StringBuilder AppendJoin(string? separator, params string?[] values)
         {
             separator ??= string.Empty;
-            fixed (char* pSeparator = separator)
-            {
-                return AppendJoinCore(pSeparator, separator.Length, values);
-            }
+            return AppendJoinCore(ref separator.GetRawStringData(), separator.Length, values);
         }
 
-        public unsafe StringBuilder AppendJoin(char separator, params object?[] values)
+        public StringBuilder AppendJoin(char separator, params object?[] values)
         {
-            return AppendJoinCore(&separator, 1, values);
+            return AppendJoinCore(ref separator, 1, values);
         }
 
-        public unsafe StringBuilder AppendJoin<T>(char separator, IEnumerable<T> values)
+        public StringBuilder AppendJoin<T>(char separator, IEnumerable<T> values)
         {
-            return AppendJoinCore(&separator, 1, values);
+            return AppendJoinCore(ref separator, 1, values);
         }
 
-        public unsafe StringBuilder AppendJoin(char separator, params string?[] values)
+        public StringBuilder AppendJoin(char separator, params string?[] values)
         {
-            return AppendJoinCore(&separator, 1, values);
+            return AppendJoinCore(ref separator, 1, values);
         }
 
-        private unsafe StringBuilder AppendJoinCore<T>(char* separator, int separatorLength, IEnumerable<T> values)
+        private StringBuilder AppendJoinCore<T>(ref char separator, int separatorLength, IEnumerable<T> values)
         {
-            Debug.Assert(separator != null);
+            Debug.Assert(!Unsafe.IsNullRef(ref separator));
             Debug.Assert(separatorLength >= 0);
 
             if (values == null)
@@ -1325,7 +1233,7 @@ private unsafe StringBuilder AppendJoinCore<T>(char* separator, int separatorLen
 
                 while (en.MoveNext())
                 {
-                    Append(separator, separatorLength);
+                    Append(ref separator, separatorLength);
                     value = en.Current;
                     if (value != null)
                     {
@@ -1336,7 +1244,7 @@ private unsafe StringBuilder AppendJoinCore<T>(char* separator, int separatorLen
             return this;
         }
 
-        private unsafe StringBuilder AppendJoinCore<T>(char* separator, int separatorLength, T[] values)
+        private StringBuilder AppendJoinCore<T>(ref char separator, int separatorLength, T[] values)
         {
             if (values == null)
             {
@@ -1356,7 +1264,7 @@ private unsafe StringBuilder AppendJoinCore<T>(char* separator, int separatorLen
 
             for (int i = 1; i < values.Length; i++)
             {
-                Append(separator, separatorLength);
+                Append(ref separator, separatorLength);
                 if (values[i] != null)
                 {
                     Append(values[i]!.ToString());
@@ -1376,12 +1284,9 @@ public StringBuilder Insert(int index, string? value)
 
             if (value != null)
             {
-                unsafe
-                {
-                    fixed (char* sourcePtr = value)
-                        Insert(index, sourcePtr, value.Length);
-                }
+                Insert(index, ref value.GetRawStringData(), value.Length);
             }
+
             return this;
         }
 
@@ -1396,10 +1301,7 @@ public StringBuilder Insert(int index, string? value)
 
         public StringBuilder Insert(int index, char value)
         {
-            unsafe
-            {
-                Insert(index, &value, 1);
-            }
+            Insert(index, ref value, 1);
             return this;
         }
 
@@ -1451,12 +1353,9 @@ public StringBuilder Insert(int index, char[]? value, int startIndex, int charCo
 
             if (charCount > 0)
             {
-                unsafe
-                {
-                    fixed (char* sourcePtr = &value[startIndex])
-                        Insert(index, sourcePtr, charCount);
-                }
+                Insert(index, ref value[startIndex], charCount);
             }
+
             return this;
         }
 
@@ -1488,14 +1387,11 @@ public StringBuilder Insert(int index, ReadOnlySpan<char> value)
                 throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_Index);
             }
 
-            if (value.Length > 0)
+            if (value.Length != 0)
             {
-                unsafe
-                {
-                    fixed (char* sourcePtr = &MemoryMarshal.GetReference(value))
-                        Insert(index, sourcePtr, value.Length);
-                }
+                Insert(index, ref MemoryMarshal.GetReference(value), value.Length);
             }
+
             return this;
         }
 
@@ -1776,7 +1672,7 @@ internal StringBuilder AppendFormatHelper(IFormatProvider? provider, string form
                         if ((uint)charsWritten > (uint)RemainingCurrentChunk.Length)
                         {
                             // Untrusted ISpanFormattable implementations might return an erroneous charsWritten value,
-                            // and m_ChunkLength might end up being used in unsafe code, so fail if we get back an
+                            // and m_ChunkLength might end up being used in Unsafe code, so fail if we get back an
                             // out-of-range charsWritten value.
                             FormatError();
                         }
@@ -1972,7 +1868,8 @@ public StringBuilder Replace(string oldValue, string? newValue, int startIndex,
             while (count > 0)
             {
                 Debug.Assert(chunk != null, "chunk was null in replace");
-                // Look for a match in the chunk,indexInChunk pointer
+
+                // Look for a match in the chunk,indexInChunk reference
                 if (StartsWith(chunk, indexInChunk, count, oldValue))
                 {
                     // Push it on the replacements array (with growth), we will do all replacements in a
@@ -2093,51 +1990,81 @@ public unsafe StringBuilder Append(char* value, int valueCount)
                 throw new ArgumentOutOfRangeException(nameof(valueCount), SR.ArgumentOutOfRange_NegativeCount);
             }
 
-            // this is where we can check if the valueCount will put us over m_MaxCapacity
-            // We are doing the check here to prevent the corruption of the StringBuilder.
+            Append(ref *value, valueCount);
+            return this;
+        }
+
+        /// <summary>Appends a specified number of chars starting from the specified reference.</summary>
+        private void Append(ref char value, int valueCount)
+        {
+            Debug.Assert(valueCount >= 0, $"Invalid length; should have been validated by caller.");
+            if (valueCount != 0)
+            {
+                char[] chunkChars = m_ChunkChars;
+                int chunkLength = m_ChunkLength;
+
+                if (((uint)chunkLength + (uint)valueCount) <= (uint)chunkChars.Length)
+                {
+                    ref char destination = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength);
+                    if (valueCount <= 2)
+                    {
+                        destination = value;
+                        if (valueCount == 2)
+                        {
+                            Unsafe.Add(ref destination, 1) = Unsafe.Add(ref value, 1);
+                        }
+                    }
+                    else
+                    {
+                        Buffer.Memmove(ref destination, ref value, (nuint)valueCount);
+                    }
+
+                    m_ChunkLength = chunkLength + valueCount;
+                }
+                else
+                {
+                    AppendWithExpansion(ref value, valueCount);
+                }
+            }
+        }
+
+        private void AppendWithExpansion(ref char value, int valueCount)
+        {
+            // Check if the valueCount will put us over m_MaxCapacity.
+            // Doing the check here prevents corruption of the StringBuilder.
             int newLength = Length + valueCount;
             if (newLength > m_MaxCapacity || newLength < valueCount)
             {
                 throw new ArgumentOutOfRangeException(nameof(valueCount), SR.ArgumentOutOfRange_LengthGreaterThanCapacity);
             }
 
-            // This case is so common we want to optimize for it heavily.
-            int newIndex = valueCount + m_ChunkLength;
-            if (newIndex <= m_ChunkChars.Length)
+            // Copy the first chunk
+            int firstLength = m_ChunkChars.Length - m_ChunkLength;
+            if (firstLength > 0)
             {
-                new ReadOnlySpan<char>(value, valueCount).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));
-                m_ChunkLength = newIndex;
+                new ReadOnlySpan<char>(ref value, firstLength).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));
+                m_ChunkLength = m_ChunkChars.Length;
             }
-            else
-            {
-                // Copy the first chunk
-                int firstLength = m_ChunkChars.Length - m_ChunkLength;
-                if (firstLength > 0)
-                {
-                    new ReadOnlySpan<char>(value, firstLength).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));
-                    m_ChunkLength = m_ChunkChars.Length;
-                }
 
-                // Expand the builder to add another chunk.
-                int restLength = valueCount - firstLength;
-                ExpandByABlock(restLength);
-                Debug.Assert(m_ChunkLength == 0, "A new block was not created.");
+            // Expand the builder to add another chunk.
+            int restLength = valueCount - firstLength;
+            ExpandByABlock(restLength);
+            Debug.Assert(m_ChunkLength == 0, "A new block was not created.");
+
+            // Copy the second chunk
+            new ReadOnlySpan<char>(ref Unsafe.Add(ref value, firstLength), restLength).CopyTo(m_ChunkChars);
+            m_ChunkLength = restLength;
 
-                // Copy the second chunk
-                new ReadOnlySpan<char>(value + firstLength, restLength).CopyTo(m_ChunkChars);
-                m_ChunkLength = restLength;
-            }
             AssertInvariants();
-            return this;
         }
 
         /// <summary>
         /// Inserts a character buffer into this builder at the specified position.
         /// </summary>
         /// <param name="index">The index to insert in this builder.</param>
-        /// <param name="value">The pointer to the start of the buffer.</param>
+        /// <param name="value">The reference to the start of the buffer.</param>
         /// <param name="valueCount">The number of characters in the buffer.</param>
-        private unsafe void Insert(int index, char* value, int valueCount)
+        private void Insert(int index, ref char value, int valueCount)
         {
             if ((uint)index > (uint)Length)
             {
@@ -2147,7 +2074,7 @@ private unsafe void Insert(int index, char* value, int valueCount)
             if (valueCount > 0)
             {
                 MakeRoom(index, valueCount, out StringBuilder chunk, out int indexInChunk, false);
-                ReplaceInPlaceAtChunk(ref chunk!, ref indexInChunk, value, valueCount);
+                ReplaceInPlaceAtChunk(ref chunk!, ref indexInChunk, ref value, valueCount);
             }
         }
 
@@ -2168,64 +2095,57 @@ private void ReplaceAllInChunk(ReadOnlySpan<int> replacements, StringBuilder sou
                 return;
             }
 
-            unsafe
+            // calculate the total amount of extra space or space needed for all the replacements.
+            long longDelta = (value.Length - removeCount) * (long)replacements.Length;
+            int delta = (int)longDelta;
+            if (delta != longDelta)
             {
-                fixed (char* valuePtr = value)
-                {
-                    // calculate the total amount of extra space or space needed for all the replacements.
-                    long longDelta = (value.Length - removeCount) * (long)replacements.Length;
-                    int delta = (int)longDelta;
-                    if (delta != longDelta)
-                    {
-                        throw new OutOfMemoryException();
-                    }
-
-                    StringBuilder targetChunk = sourceChunk;        // the target as we copy chars down
-                    int targetIndexInChunk = replacements[0];
+                throw new OutOfMemoryException();
+            }
 
-                    // Make the room needed for all the new characters if needed.
-                    if (delta > 0)
-                    {
-                        MakeRoom(targetChunk.m_ChunkOffset + targetIndexInChunk, delta, out targetChunk, out targetIndexInChunk, true);
-                    }
+            StringBuilder targetChunk = sourceChunk;        // the target as we copy chars down
+            int targetIndexInChunk = replacements[0];
 
-                    // We made certain that characters after the insertion point are not moved,
-                    int i = 0;
-                    while (true)
-                    {
-                        // Copy in the new string for the ith replacement
-                        ReplaceInPlaceAtChunk(ref targetChunk!, ref targetIndexInChunk, valuePtr, value.Length);
-                        int gapStart = replacements[i] + removeCount;
-                        i++;
-                        if ((uint)i >= replacements.Length)
-                        {
-                            break;
-                        }
+            // Make the room needed for all the new characters if needed.
+            if (delta > 0)
+            {
+                MakeRoom(targetChunk.m_ChunkOffset + targetIndexInChunk, delta, out targetChunk, out targetIndexInChunk, true);
+            }
 
-                        int gapEnd = replacements[i];
-                        Debug.Assert(gapStart < sourceChunk.m_ChunkChars.Length, "gap starts at end of buffer.  Should not happen");
-                        Debug.Assert(gapStart <= gapEnd, "negative gap size");
-                        Debug.Assert(gapEnd <= sourceChunk.m_ChunkLength, "gap too big");
-                        if (delta != 0)     // can skip the sliding of gaps if source an target string are the same size.
-                        {
-                            // Copy the gap data between the current replacement and the next replacement
-                            fixed (char* sourcePtr = &sourceChunk.m_ChunkChars[gapStart])
-                                ReplaceInPlaceAtChunk(ref targetChunk!, ref targetIndexInChunk, sourcePtr, gapEnd - gapStart);
-                        }
-                        else
-                        {
-                            targetIndexInChunk += gapEnd - gapStart;
-                            Debug.Assert(targetIndexInChunk <= targetChunk.m_ChunkLength, "gap not in chunk");
-                        }
-                    }
+            // We made certain that characters after the insertion point are not moved,
+            int i = 0;
+            while (true)
+            {
+                // Copy in the new string for the ith replacement
+                ReplaceInPlaceAtChunk(ref targetChunk!, ref targetIndexInChunk, ref value.GetRawStringData(), value.Length);
+                int gapStart = replacements[i] + removeCount;
+                i++;
+                if ((uint)i >= replacements.Length)
+                {
+                    break;
+                }
 
-                    // Remove extra space if necessary.
-                    if (delta < 0)
-                    {
-                        Remove(targetChunk.m_ChunkOffset + targetIndexInChunk, -delta, out targetChunk, out targetIndexInChunk);
-                    }
+                int gapEnd = replacements[i];
+                Debug.Assert(gapStart < sourceChunk.m_ChunkChars.Length, "gap starts at end of buffer.  Should not happen");
+                Debug.Assert(gapStart <= gapEnd, "negative gap size");
+                Debug.Assert(gapEnd <= sourceChunk.m_ChunkLength, "gap too big");
+                if (delta != 0)     // can skip the sliding of gaps if source an target string are the same size.
+                {
+                    // Copy the gap data between the current replacement and the next replacement
+                    ReplaceInPlaceAtChunk(ref targetChunk!, ref targetIndexInChunk, ref sourceChunk.m_ChunkChars[gapStart], gapEnd - gapStart);
+                }
+                else
+                {
+                    targetIndexInChunk += gapEnd - gapStart;
+                    Debug.Assert(targetIndexInChunk <= targetChunk.m_ChunkLength, "gap not in chunk");
                 }
             }
+
+            // Remove extra space if necessary.
+            if (delta < 0)
+            {
+                Remove(targetChunk.m_ChunkOffset + targetIndexInChunk, -delta, out targetChunk, out targetIndexInChunk);
+            }
         }
 
         /// <summary>
@@ -2278,9 +2198,9 @@ private bool StartsWith(StringBuilder chunk, int indexInChunk, int count, string
         /// The index in <paramref name="chunk"/> to start replacing characters at.
         /// Receives the index at which character replacement ends.
         /// </param>
-        /// <param name="value">The pointer to the start of the character buffer.</param>
+        /// <param name="value">The reference to the start of the character buffer.</param>
         /// <param name="count">The number of characters in the buffer.</param>
-        private unsafe void ReplaceInPlaceAtChunk(ref StringBuilder? chunk, ref int indexInChunk, char* value, int count)
+        private void ReplaceInPlaceAtChunk(ref StringBuilder? chunk, ref int indexInChunk, ref char value, int count)
         {
             if (count != 0)
             {
@@ -2291,7 +2211,7 @@ private unsafe void ReplaceInPlaceAtChunk(ref StringBuilder? chunk, ref int inde
                     Debug.Assert(lengthInChunk >= 0, "Index isn't in the chunk.");
 
                     int lengthToCopy = Math.Min(lengthInChunk, count);
-                    new ReadOnlySpan<char>(value, lengthToCopy).CopyTo(chunk.m_ChunkChars.AsSpan(indexInChunk));
+                    new ReadOnlySpan<char>(ref value, lengthToCopy).CopyTo(chunk.m_ChunkChars.AsSpan(indexInChunk));
 
                     // Advance the index.
                     indexInChunk += lengthToCopy;
@@ -2305,7 +2225,7 @@ private unsafe void ReplaceInPlaceAtChunk(ref StringBuilder? chunk, ref int inde
                     {
                         break;
                     }
-                    value += lengthToCopy;
+                    value = ref Unsafe.Add(ref value, lengthToCopy);
                 }
             }
         }
@@ -2345,8 +2265,8 @@ private Span<char> RemainingCurrentChunk
         /// </summary>
         /// <param name="chunk">The chunk whose successor should be found.</param>
         /// <remarks>
-        /// Each chunk only stores the pointer to its logical predecessor, so this routine has to start
-        /// from the 'this' pointer (which is assumed to represent the whole StringBuilder) and work its
+        /// Each chunk only stores the reference to its logical predecessor, so this routine has to start
+        /// from the 'this' reference (which is assumed to represent the whole StringBuilder) and work its
         /// way down until it finds the specified chunk (which is O(n)). Thus, it is more expensive than
         /// a field fetch.
         /// </remarks>
@@ -2387,7 +2307,7 @@ private void ExpandByABlock(int minBlockCharCount)
             // Allocate the array before updating any state to avoid leaving inconsistent state behind in case of out of memory exception
             char[] chunkChars = GC.AllocateUninitializedArray<char>(newBlockLength);
 
-            // Move all of the data from this chunk to a new one, via a few O(1) pointer adjustments.
+            // Move all of the data from this chunk to a new one, via a few O(1) reference adjustments.
             // Then, have this chunk point to the new one as its predecessor.
             m_ChunkPrevious = new StringBuilder(this);
             m_ChunkOffset += m_ChunkLength;
@@ -2705,7 +2625,7 @@ public void AppendFormatted<T>(T value)
                             if ((uint)charsWritten > (uint)destination.Length)
                             {
                                 // Protect against faulty ISpanFormattable implementations returning invalid charsWritten values.
-                                // Other code in _stringBuilder uses unsafe manipulation, and we want to ensure m_ChunkLength remains safe.
+                                // Other code in _stringBuilder uses Unsafe manipulation, and we want to ensure m_ChunkLength remains safe.
                                 FormatError();
                             }
 
@@ -2758,7 +2678,7 @@ public void AppendFormatted<T>(T value, string? format)
                             if ((uint)charsWritten > (uint)destination.Length)
                             {
                                 // Protect against faulty ISpanFormattable implementations returning invalid charsWritten values.
-                                // Other code in _stringBuilder uses unsafe manipulation, and we want to ensure m_ChunkLength remains safe.
+                                // Other code in _stringBuilder uses Unsafe manipulation, and we want to ensure m_ChunkLength remains safe.
                                 FormatError();
                             }
 

From c7adf5598f27e59644030ddae4e382cbda74e41e Mon Sep 17 00:00:00 2001
From: Jo Shields <directhex@apebox.org>
Date: Fri, 28 Jan 2022 15:15:35 -0500
Subject: [PATCH 154/161] Check for CMAKE_C_COMPILER_ID not CXX (#64226)

* Check for CMAKE_C_COMPILER_ID not CXX

In some cases, CMAKE_CXX_COMPILER_ID might not be populated,
which causes the toolchaine prefix checks to be ignored, which
causes the build to look for `ranlib` not `llvm-ranlib`, which
causes it to use XCode ranlib instead of Android NDK ranlib for
builds, which doesn't work.

Hopefully (we'll see what CI says) this doesn't regress other builds.

Closes: #55412

* Update eng/native/configuretools.cmake

Co-authored-by: Adeel Mujahid <3840695+am11@users.noreply.github.com>

* Use llvm-objcopy, not GNU, on Android

It's available in r21 (which we use today) and works for r23
(which has no GNU objcopy any more and breaks without this change)

Co-authored-by: Adeel Mujahid <3840695+am11@users.noreply.github.com>
---
 eng/native/configuretools.cmake | 6 +++---
 src/mono/mono.proj              | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/eng/native/configuretools.cmake b/eng/native/configuretools.cmake
index ad5dc38107c33f..860e46427b6b08 100644
--- a/eng/native/configuretools.cmake
+++ b/eng/native/configuretools.cmake
@@ -7,15 +7,15 @@ if (CMAKE_C_COMPILER MATCHES "-?[0-9]+(\.[0-9]+)?$")
 endif()
 
 if(NOT WIN32 AND NOT CLR_CMAKE_TARGET_BROWSER)
-  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  if(CMAKE_C_COMPILER_ID MATCHES "Clang")
     if(APPLE)
       set(TOOLSET_PREFIX "")
     else()
       set(TOOLSET_PREFIX "llvm-")
     endif()
-  elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  elseif(CMAKE_C_COMPILER_ID MATCHES "GNU")
     if(CMAKE_CROSSCOMPILING)
-      set(TOOLSET_PREFIX "${CMAKE_CXX_COMPILER_TARGET}-")
+      set(TOOLSET_PREFIX "${CMAKE_C_COMPILER_TARGET}-")
     else()
       set(TOOLSET_PREFIX "")
     endif()
diff --git a/src/mono/mono.proj b/src/mono/mono.proj
index bff71d03b47e9c..ed1945437a6689 100644
--- a/src/mono/mono.proj
+++ b/src/mono/mono.proj
@@ -530,7 +530,7 @@
       <_Objcopy Condition="'$(Platform)' == 's390x'">s390x-linux-$(_LinuxAbi)-$(_Objcopy)</_Objcopy>
       <_Objcopy Condition="'$(Platform)' == 'x64'">x86_64-linux-$(_LinuxAbi)-$(_Objcopy)</_Objcopy>
       <_Objcopy Condition="'$(Platform)' == 'x86'">i686-linux-$(_LinuxAbi)-$(_Objcopy)</_Objcopy>
-      <_Objcopy Condition="'$(TargetsAndroid)' == 'true'">$(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/$(MonoToolchainPrebuiltOS)/bin/$(_Objcopy)</_Objcopy>
+      <_Objcopy Condition="'$(TargetsAndroid)' == 'true'">$(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/$(MonoToolchainPrebuiltOS)/bin/llvm-objcopy</_Objcopy>
     </PropertyGroup>
     <!-- test viability of objcopy command -->
     <Exec Condition="'$(BuildMonoAOTCrossCompilerOnly)' != 'true' and ('$(TargetsLinux)' == 'true' or '$(TargetsAndroid)' == 'true')" Command="$(_Objcopy) -V" IgnoreStandardErrorWarningFormat="true" ContinueOnError="WarnAndContinue" IgnoreExitCode="true" EchoOff="true" ConsoleToMsBuild="true">

From 964b1d74276a7d7937689036af593954eac0d5c3 Mon Sep 17 00:00:00 2001
From: Tomas Weinfurt <tweinfurt@yahoo.com>
Date: Fri, 28 Jan 2022 15:44:55 -0800
Subject: [PATCH 155/161] remove support for Ssl2 (#64322)

* remove support for Ssl2

* update test

* update exeception type

* remove Sslv2 test
---
 .../Net/Security/SslStream.Implementation.cs  | 263 ++----------------
 .../ClientAsyncAuthenticateTest.cs            |  14 -
 .../ServerAsyncAuthenticateTest.cs            |   9 +-
 3 files changed, 23 insertions(+), 263 deletions(-)

diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs
index 34550835ead047..58156e3d76a94d 100644
--- a/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs
+++ b/src/libraries/System.Net.Security/src/System/Net/Security/SslStream.Implementation.cs
@@ -21,18 +21,6 @@ public partial class SslStream
         private int _nestedAuth;
         private bool _isRenego;
 
-        private enum Framing
-        {
-            Unknown = 0,    // Initial before any frame is processed.
-            BeforeSSL3,     // SSlv2
-            SinceSSL3,      // SSlv3 & TLS
-            Unified,        // Intermediate on first frame until response is processes.
-            Invalid         // Something is wrong.
-        }
-
-        // This is set on the first packet to figure out the framing style.
-        private Framing _framing = Framing.Unknown;
-
         private TlsFrameHelper.TlsFrameInfo _lastFrame;
 
         private object _handshakeLock => _sslAuthenticationOptions!;
@@ -460,27 +448,12 @@ private async ValueTask<ProtocolToken> ReceiveBlobAsync<TIOAdapter>(TIOAdapter a
                  where TIOAdapter : IReadWriteAdapter
         {
             await FillHandshakeBufferAsync(adapter, SecureChannel.ReadHeaderSize).ConfigureAwait(false);
-            if (_framing == Framing.Unified || _framing == Framing.Unknown)
-            {
-                _framing = DetectFraming(_handshakeBuffer.ActiveReadOnlySpan);
-            }
-
-            if (_framing != Framing.SinceSSL3)
-            {
-#pragma warning disable 0618
-                _lastFrame.Header.Version = SslProtocols.Ssl2;
-#pragma warning restore 0618
-                _lastFrame.Header.Length = GetFrameSize(_handshakeBuffer.ActiveReadOnlySpan) - TlsFrameHelper.HeaderSize;
-            }
-            else
-            {
-                TlsFrameHelper.TryGetFrameHeader(_handshakeBuffer.ActiveReadOnlySpan, ref _lastFrame.Header);
-            }
+            TlsFrameHelper.TryGetFrameHeader(_handshakeBuffer.ActiveReadOnlySpan, ref _lastFrame.Header);
 
             if (_lastFrame.Header.Length < 0)
             {
                 if (NetEventSource.Log.IsEnabled()) NetEventSource.Error(this, "invalid TLS frame size");
-                throw new IOException(SR.net_frame_read_size);
+                throw new AuthenticationException(SR.net_frame_read_size);
             }
 
             // Header length is content only so we must add header size as well.
@@ -560,29 +533,26 @@ private ProtocolToken ProcessBlob(int frameSize)
             // ActiveSpan will exclude the "discarded" data.
             _handshakeBuffer.Discard(frameSize);
 
-            if (_framing == Framing.SinceSSL3)
+            // Often more TLS messages fit into same packet. Get as many complete frames as we can.
+            while (_handshakeBuffer.ActiveLength > TlsFrameHelper.HeaderSize)
             {
-                // Often more TLS messages fit into same packet. Get as many complete frames as we can.
-                while (_handshakeBuffer.ActiveLength > TlsFrameHelper.HeaderSize)
-                {
-                    TlsFrameHeader nextHeader = default;
-
-                    if (!TlsFrameHelper.TryGetFrameHeader(_handshakeBuffer.ActiveReadOnlySpan, ref nextHeader))
-                    {
-                        break;
-                    }
+                TlsFrameHeader nextHeader = default;
 
-                    frameSize = nextHeader.Length + TlsFrameHelper.HeaderSize;
-                    // Can process more handshake frames in single step, but we should avoid processing too much so as to preserve API boundary between handshake and I/O.
-                    if ((nextHeader.Type != TlsContentType.Handshake && nextHeader.Type != TlsContentType.ChangeCipherSpec) || frameSize > _handshakeBuffer.ActiveLength)
-                    {
-                        // We don't have full frame left or we already have app data which needs to be processed by decrypt.
-                        break;
-                    }
+                if (!TlsFrameHelper.TryGetFrameHeader(_handshakeBuffer.ActiveReadOnlySpan, ref nextHeader))
+                {
+                    break;
+                }
 
-                    chunkSize += frameSize;
-                    _handshakeBuffer.Discard(frameSize);
+                frameSize = nextHeader.Length + TlsFrameHelper.HeaderSize;
+                // Can process more handshake frames in single step, but we should avoid processing too much so as to preserve API boundary between handshake and I/O.
+                if ((nextHeader.Type != TlsContentType.Handshake && nextHeader.Type != TlsContentType.ChangeCipherSpec) || frameSize > _handshakeBuffer.ActiveLength)
+                {
+                    // We don't have full frame left or we already have app data which needs to be processed by decrypt.
+                    break;
                 }
+
+                chunkSize += frameSize;
+                _handshakeBuffer.Discard(frameSize);
             }
 
             return _context!.NextMessage(availableData.Slice(0, chunkSize));
@@ -1199,204 +1169,15 @@ private void ResetReadBuffer()
             }
         }
 
-        // We need at least 5 bytes to determine what we have.
-        private Framing DetectFraming(ReadOnlySpan<byte> bytes)
-        {
-            /* PCTv1.0 Hello starts with
-             * RECORD_LENGTH_MSB  (ignore)
-             * RECORD_LENGTH_LSB  (ignore)
-             * PCT1_CLIENT_HELLO  (must be equal)
-             * PCT1_CLIENT_VERSION_MSB (if version greater than PCTv1)
-             * PCT1_CLIENT_VERSION_LSB (if version greater than PCTv1)
-             *
-             * ... PCT hello ...
-             */
-
-            /* Microsoft Unihello starts with
-             * RECORD_LENGTH_MSB  (ignore)
-             * RECORD_LENGTH_LSB  (ignore)
-             * SSL2_CLIENT_HELLO  (must be equal)
-             * SSL2_CLIENT_VERSION_MSB (if version greater than SSLv2) ( or v3)
-             * SSL2_CLIENT_VERSION_LSB (if version greater than SSLv2) ( or v3)
-             *
-             * ... SSLv2 Compatible Hello ...
-             */
-
-            /* SSLv2 CLIENT_HELLO starts with
-             * RECORD_LENGTH_MSB  (ignore)
-             * RECORD_LENGTH_LSB  (ignore)
-             * SSL2_CLIENT_HELLO  (must be equal)
-             * SSL2_CLIENT_VERSION_MSB (if version greater than SSLv2) ( or v3)
-             * SSL2_CLIENT_VERSION_LSB (if version greater than SSLv2) ( or v3)
-             *
-             * ... SSLv2 CLIENT_HELLO ...
-             */
-
-            /* SSLv2 SERVER_HELLO starts with
-             * RECORD_LENGTH_MSB  (ignore)
-             * RECORD_LENGTH_LSB  (ignore)
-             * SSL2_SERVER_HELLO  (must be equal)
-             * SSL2_SESSION_ID_HIT (ignore)
-             * SSL2_CERTIFICATE_TYPE (ignore)
-             * SSL2_CLIENT_VERSION_MSB (if version greater than SSLv2) ( or v3)
-             * SSL2_CLIENT_VERSION_LSB (if version greater than SSLv2) ( or v3)
-             *
-             * ... SSLv2 SERVER_HELLO ...
-             */
-
-            /* SSLv3 Type 2 Hello starts with
-              * RECORD_LENGTH_MSB  (ignore)
-              * RECORD_LENGTH_LSB  (ignore)
-              * SSL2_CLIENT_HELLO  (must be equal)
-              * SSL2_CLIENT_VERSION_MSB (if version greater than SSLv3)
-              * SSL2_CLIENT_VERSION_LSB (if version greater than SSLv3)
-              *
-              * ... SSLv2 Compatible Hello ...
-              */
-
-            /* SSLv3 Type 3 Hello starts with
-             * 22 (HANDSHAKE MESSAGE)
-             * VERSION MSB
-             * VERSION LSB
-             * RECORD_LENGTH_MSB  (ignore)
-             * RECORD_LENGTH_LSB  (ignore)
-             * HS TYPE (CLIENT_HELLO)
-             * 3 bytes HS record length
-             * HS Version
-             * HS Version
-             */
-
-            /* SSLv2 message codes
-             * SSL_MT_ERROR                0
-             * SSL_MT_CLIENT_HELLO         1
-             * SSL_MT_CLIENT_MASTER_KEY    2
-             * SSL_MT_CLIENT_FINISHED      3
-             * SSL_MT_SERVER_HELLO         4
-             * SSL_MT_SERVER_VERIFY        5
-             * SSL_MT_SERVER_FINISHED      6
-             * SSL_MT_REQUEST_CERTIFICATE  7
-             * SSL_MT_CLIENT_CERTIFICATE   8
-             */
-
-            int version = -1;
-
-            Debug.Assert(bytes.Length != 0, "Header buffer is not allocated.");
-
-            // If the first byte is SSL3 HandShake, then check if we have a SSLv3 Type3 client hello.
-            if (bytes[0] == (byte)TlsContentType.Handshake || bytes[0] == (byte)TlsContentType.AppData
-                || bytes[0] == (byte)TlsContentType.Alert)
-            {
-                if (bytes.Length < 3)
-                {
-                    return Framing.Invalid;
-                }
-
-                version = (bytes[1] << 8) | bytes[2];
-                if (version < 0x300 || version >= 0x500)
-                {
-                    return Framing.Invalid;
-                }
-
-                //
-                // This is an SSL3 Framing
-                //
-                return Framing.SinceSSL3;
-            }
-
-            if (bytes.Length < 3)
-            {
-                return Framing.Invalid;
-            }
-
-            if (bytes[2] > 8)
-            {
-                return Framing.Invalid;
-            }
-
-            if (bytes[2] == 0x1)  // SSL_MT_CLIENT_HELLO
-            {
-                if (bytes.Length >= 5)
-                {
-                    version = (bytes[3] << 8) | bytes[4];
-                }
-            }
-            else if (bytes[2] == 0x4) // SSL_MT_SERVER_HELLO
-            {
-                if (bytes.Length >= 7)
-                {
-                    version = (bytes[5] << 8) | bytes[6];
-                }
-            }
-
-            if (version != -1)
-            {
-                // If this is the first packet, the client may start with an SSL2 packet
-                // but stating that the version is 3.x, so check the full range.
-                // For the subsequent packets we assume that an SSL2 packet should have a 2.x version.
-                if (_framing == Framing.Unknown)
-                {
-                    if (version != 0x0002 && (version < 0x200 || version >= 0x500))
-                    {
-                        return Framing.Invalid;
-                    }
-                }
-                else
-                {
-                    if (version != 0x0002)
-                    {
-                        return Framing.Invalid;
-                    }
-                }
-            }
-
-            // When server has replied the framing is already fixed depending on the prior client packet
-            if (!_context!.IsServer || _framing == Framing.Unified)
-            {
-                return Framing.BeforeSSL3;
-            }
-
-            return Framing.Unified; // Will use Ssl2 just for this frame.
-        }
-
-        // Returns TLS Frame size.
+        // Returns TLS Frame size including header size.
         private int GetFrameSize(ReadOnlySpan<byte> buffer)
         {
-            int payloadSize;
-            switch (_framing)
+            if (buffer.Length < SecureChannel.ReadHeaderSize)
             {
-                case Framing.Unified:
-                case Framing.BeforeSSL3:
-                    if (buffer.Length < 2)
-                    {
-                        throw new IOException(SR.net_ssl_io_frame);
-                    }
-                    // Note: Cannot detect version mismatch for <= SSL2
-
-                    if ((buffer[0] & 0x80) != 0)
-                    {
-                        // Two bytes
-                        payloadSize = (((buffer[0] & 0x7f) << 8) | buffer[1]) + 2;
-                    }
-                    else
-                    {
-                        // Three bytes
-                        payloadSize = (((buffer[0] & 0x3f) << 8) | buffer[1]) + 3;
-                    }
-
-                    break;
-                case Framing.SinceSSL3:
-                    if (buffer.Length < 5)
-                    {
-                        throw new IOException(SR.net_ssl_io_frame);
-                    }
-
-                    payloadSize = ((buffer[3] << 8) | buffer[4]) + 5;
-                    break;
-                default:
-                    throw new IOException(SR.net_frame_read_size);
+                throw new IOException(SR.net_ssl_io_frame);
             }
 
-            return payloadSize;
+            return ((buffer[3] << 8) | buffer[4]) + SecureChannel.ReadHeaderSize;
         }
     }
 }
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/ClientAsyncAuthenticateTest.cs b/src/libraries/System.Net.Security/tests/FunctionalTests/ClientAsyncAuthenticateTest.cs
index 50dd158345ff77..a0e76e49354fbd 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/ClientAsyncAuthenticateTest.cs
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/ClientAsyncAuthenticateTest.cs
@@ -52,20 +52,6 @@ public async Task ClientAsyncAuthenticate_EachSupportedProtocol_Success(SslProto
             await ClientAsyncSslHelper(protocol, protocol);
         }
 
-        [Fact]
-        [PlatformSpecific(TestPlatforms.Windows)]
-        public async Task ClientAsyncAuthenticate_Ssl2WithSelf_Success()
-        {
-            // Test Ssl2 against itself. This is a standalone test as even on versions where Windows supports Ssl2,
-            // it appears to have rules around not using it when other protocols are mentioned.
-            if (PlatformDetection.SupportsSsl2)
-            {
-#pragma warning disable 0618
-                await ClientAsyncSslHelper(SslProtocols.Ssl2, SslProtocols.Ssl2);
-#pragma warning restore 0618
-            }
-        }
-
         [Theory]
         [MemberData(nameof(ProtocolMismatchData))]
         public async Task ClientAsyncAuthenticate_MismatchProtocols_Fails(
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/ServerAsyncAuthenticateTest.cs b/src/libraries/System.Net.Security/tests/FunctionalTests/ServerAsyncAuthenticateTest.cs
index 6edcace7d85a54..1e01be34ca3ded 100644
--- a/src/libraries/System.Net.Security/tests/FunctionalTests/ServerAsyncAuthenticateTest.cs
+++ b/src/libraries/System.Net.Security/tests/FunctionalTests/ServerAsyncAuthenticateTest.cs
@@ -317,14 +317,7 @@ public async Task ServerAsyncAuthenticate_InvalidHello_Throws(bool close)
                     await t2.WaitAsync(TestConfiguration.PassingTestTimeout);
                 }
 
-                if (close)
-                {
-                    await Assert.ThrowsAsync<IOException>(() => t1);
-                }
-                else
-                {
-                    await Assert.ThrowsAsync<AuthenticationException>(() => t1);
-                }
+                await Assert.ThrowsAsync<AuthenticationException>(() => t1);
             }
         }
 

From 9122424d908d53a50f3750f6caf4c88512c36311 Mon Sep 17 00:00:00 2001
From: Bruce Forstall <brucefo@microsoft.com>
Date: Fri, 28 Jan 2022 16:50:33 -0800
Subject: [PATCH 156/161] Fix JIT rolling build issue with non-JIT changes
 (#64480)

When uploading a JIT rolling build, use the git hash of the most recent
JIT change, not the git hash that was actually built. This handles the case
where a JIT change kicked off an AzDO pipeline, but the pipeline didn't start
until after one or more additional changes were merged.

The AzDO pipelines appear to fetch with `-depth=20`, which should provide
enough history for almost any case.

Fixes #64392
---
 .../coreclr/templates/build-jit-job.yml       |  2 +-
 src/coreclr/scripts/jitrollingbuild.py        | 41 ++++++++++++++++++-
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/eng/pipelines/coreclr/templates/build-jit-job.yml b/eng/pipelines/coreclr/templates/build-jit-job.yml
index 2022a8c53a24fd..b5ff3df213af30 100644
--- a/eng/pipelines/coreclr/templates/build-jit-job.yml
+++ b/eng/pipelines/coreclr/templates/build-jit-job.yml
@@ -118,7 +118,7 @@ jobs:
       - script: $(PipScript) install --user --upgrade pip && $(PipScript) install --user azure.storage.blob==12.5.0 --force-reinstall
         displayName: Upgrade Pip to latest and install azure-storage-blob Python package
 
-      - script: $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/jitrollingbuild.py upload -build_type $(buildConfig) -arch $(archType) -host_os $(osGroup) -git_hash $(Build.SourceVersion)
+      - script: $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/jitrollingbuild.py upload -build_type $(buildConfig) -arch $(archType) -host_os $(osGroup) -git_hash $(Build.SourceVersion) --use_latest_jit_change
         displayName: Upload JIT to Azure Storage
         env:
           CLRJIT_AZ_KEY: $(clrjit_key1) # secret key stored as variable in pipeline
diff --git a/src/coreclr/scripts/jitrollingbuild.py b/src/coreclr/scripts/jitrollingbuild.py
index 100aff85c35226..71e7d148a61d1d 100644
--- a/src/coreclr/scripts/jitrollingbuild.py
+++ b/src/coreclr/scripts/jitrollingbuild.py
@@ -74,6 +74,13 @@
 
 git_hash_help = "git hash"
 
+use_latest_jit_change_help = """\
+Starting with the given git hash, look backwards in the git log for the first change that includes any JIT
+change. We want to ensure that any git hash uploaded to the JIT rolling build store is a JIT change. This
+addresses a problem where Azure DevOps sometimes builds changes that come soon after a JIT change, instead of
+the JIT change itself.
+"""
+
 target_dir_help = "Directory to put the downloaded JIT."
 
 skip_cleanup_help = "Skip intermediate file removal."
@@ -97,6 +104,7 @@
 upload_parser = subparsers.add_parser("upload", description=upload_description, parents=[common_parser])
 
 upload_parser.add_argument("-git_hash", required=True, help=git_hash_help)
+upload_parser.add_argument("--use_latest_jit_change", action="store_true", help=use_latest_jit_change_help)
 upload_parser.add_argument("-az_storage_key", help="Key for the clrjit Azure Storage location. Default: use the value of the CLRJIT_AZ_KEY environment variable.")
 upload_parser.add_argument("--skip_cleanup", action="store_true", help=skip_cleanup_help)
 
@@ -458,6 +466,32 @@ def upload_blob(file, blob_name):
     #        pdb_paths = [os.path.join(pdb_dir, item) for item in os.listdir(pdb_dir) if re.match(r'.*clrjit.*', item)]
     #        files += pdb_paths
 
+    # Figure out which git hash to use for the upload. By default, it is the required coreclr_args.git_hash argument.
+    # However, if "--use_latest_jit_change" is passed, we look backwards in the git log for the nearest git commit
+    # with a JIT change (it could, and often will be, the same as the argument git_hash).
+    jit_git_hash = coreclr_args.git_hash
+
+    if coreclr_args.use_latest_jit_change:
+        # Do all the remaining commands, including a number of 'git' commands including relative paths,
+        # from the root of the runtime repo.
+
+        with ChangeDir(coreclr_args.runtime_repo_location):
+            # Enumerate the last change, starting with the jit_git_hash, that included JIT changes.
+            command = [ "git", "log", "--pretty=format:%H", jit_git_hash, "-1", "--", "src/coreclr/jit/*" ]
+            print("Invoking: {}".format(" ".join(command)))
+            proc = subprocess.Popen(command, stdout=subprocess.PIPE)
+            stdout_change_list, _ = proc.communicate()
+            return_code = proc.returncode
+            change_list_hashes = []
+            if return_code == 0:
+                change_list_hashes = stdout_change_list.decode('utf-8').strip().splitlines()
+
+            if len(change_list_hashes) == 0:
+                print("Couldn't find any JIT changes! Just using the argument git_hash")
+            else:
+                jit_git_hash = change_list_hashes[0]
+                print("Using git_hash {}".format(jit_git_hash))
+
     print("Uploading:")
     for item in files:
         print("  {}".format(item))
@@ -472,7 +506,7 @@ def upload_blob(file, blob_name):
         raise RuntimeError("Missing azure storage package.")
 
     blob_service_client = BlobServiceClient(account_url=az_blob_storage_account_uri, credential=coreclr_args.az_storage_key)
-    blob_folder_name = "{}/{}/{}/{}/{}".format(az_builds_root_folder, coreclr_args.git_hash, coreclr_args.host_os, coreclr_args.arch, coreclr_args.build_type)
+    blob_folder_name = "{}/{}/{}/{}/{}".format(az_builds_root_folder, jit_git_hash, coreclr_args.host_os, coreclr_args.arch, coreclr_args.build_type)
 
     total_bytes_uploaded = 0
 
@@ -684,6 +718,11 @@ def setup_spmi_location_arg(spmi_location):
                             lambda unused: True,
                             "Unable to set git_hash")
 
+        coreclr_args.verify(args,
+                            "use_latest_jit_change",
+                            lambda unused: True,
+                            "Unable to set use_latest_jit_change")
+
         coreclr_args.verify(args,
                             "az_storage_key",
                             lambda item: item is not None,

From d603356dfbf09616e55bd99ed840aa20468a9e57 Mon Sep 17 00:00:00 2001
From: Vladimir Sadov <vsadov@microsoft.com>
Date: Fri, 28 Jan 2022 17:00:27 -0800
Subject: [PATCH 157/161] More cleanups in assembly loader area (#63157)

* GetManifestFile() --> GetPEAssembly()

* GetManifestImport() -> GetMDImport()

* removed GetCurrentAssembly(), GetLoadedAssembly()

* removed GetCurrentModule(), GetLoadedModule()

* fix

* removed DomainFile::ModuleIterator

* renamed Assembly::GetManifestModule() --> GetModule()

* Removed Assembly::ModuleIterator

* move most fields off DomainAssembly

* DomainAssembly is a complete proxy

* some DomainFile --> DomainAssembly renames.

* deleted DomainFile class

* renamed files

* a few minor cleanups

* DomainAssembly does not need to have  VPTR_. Couple other changes.

* More DomainFile --> DomainAssembly renames

* More DomainFile --> DomainAssembly renames

* a few more renames

* removed domainassembly.inl

* domainassembly.h cleanup

* make gcc happy

* couple more changes

* fixed build after rebasing

* PR feedback

* more PR feedback
---
 src/coreclr/debug/daccess/dacdbiimpl.cpp      |  144 +-
 src/coreclr/debug/daccess/dacdbiimpl.h        |   26 +-
 .../debug/daccess/dacdbiimplstackwalk.cpp     |   16 +-
 src/coreclr/debug/daccess/dacimpl.h           |   27 +-
 src/coreclr/debug/daccess/request.cpp         |   30 +-
 src/coreclr/debug/daccess/task.cpp            |   24 +-
 src/coreclr/debug/di/breakpoint.cpp           |    2 +-
 src/coreclr/debug/di/divalue.cpp              |   10 +-
 src/coreclr/debug/di/module.cpp               |   56 +-
 src/coreclr/debug/di/process.cpp              |   58 +-
 src/coreclr/debug/di/rsappdomain.cpp          |   20 +-
 src/coreclr/debug/di/rsclass.cpp              |   12 +-
 src/coreclr/debug/di/rsfunction.cpp           |   12 +-
 src/coreclr/debug/di/rspriv.h                 |   22 +-
 src/coreclr/debug/di/rsstackwalk.cpp          |    2 +-
 src/coreclr/debug/di/rsthread.cpp             |   20 +-
 src/coreclr/debug/di/rstype.cpp               |   32 +-
 src/coreclr/debug/ee/debugger.cpp             |  140 +-
 src/coreclr/debug/ee/debugger.h               |   22 +-
 src/coreclr/debug/ee/debugger.inl             |    6 +-
 src/coreclr/debug/ee/debuggermodule.cpp       |    2 +-
 src/coreclr/debug/inc/dacdbiinterface.h       |   48 +-
 src/coreclr/debug/inc/dacdbistructures.h      |   16 +-
 src/coreclr/debug/inc/dacdbistructures.inl    |    4 +-
 src/coreclr/debug/inc/dbgipcevents.h          |   50 +-
 src/coreclr/inc/vptr_list.h                   |    2 -
 src/coreclr/nativeaot/Runtime/eventtrace.cpp  | 1436 +++++++++--------
 src/coreclr/vm/CMakeLists.txt                 |    5 +-
 src/coreclr/vm/appdomain.cpp                  |  138 +-
 src/coreclr/vm/appdomain.hpp                  |   45 +-
 src/coreclr/vm/assembly.cpp                   |  117 +-
 src/coreclr/vm/assembly.hpp                   |  144 +-
 src/coreclr/vm/assemblynative.cpp             |   34 +-
 src/coreclr/vm/assemblyspec.cpp               |    2 +-
 src/coreclr/vm/assemblyspec.hpp               |    2 +-
 src/coreclr/vm/ceeload.cpp                    |  102 +-
 src/coreclr/vm/ceeload.h                      |   28 +-
 src/coreclr/vm/ceeload.inl                    |   10 +-
 src/coreclr/vm/classhash.cpp                  |    2 +-
 src/coreclr/vm/clsload.cpp                    |   94 +-
 src/coreclr/vm/codeversion.cpp                |    5 +-
 src/coreclr/vm/comdynamic.cpp                 |    8 +-
 src/coreclr/vm/commodule.cpp                  |   12 +-
 src/coreclr/vm/common.h                       |    3 -
 src/coreclr/vm/coreassemblyspec.cpp           |    2 +-
 src/coreclr/vm/dbginterface.h                 |    4 +-
 src/coreclr/vm/debugdebugger.cpp              |    4 +-
 .../vm/{domainfile.cpp => domainassembly.cpp} |  328 +---
 .../vm/{domainfile.h => domainassembly.h}     |  415 ++---
 src/coreclr/vm/domainfile.inl                 |   72 -
 src/coreclr/vm/dwbucketmanager.hpp            |    4 +-
 src/coreclr/vm/dynamicmethod.cpp              |    2 +-
 src/coreclr/vm/eventtrace.cpp                 |  126 +-
 src/coreclr/vm/excep.cpp                      |    8 +-
 src/coreclr/vm/interoputil.cpp                |    8 +-
 src/coreclr/vm/jithelpers.cpp                 |   18 +-
 src/coreclr/vm/jitinterface.cpp               |    4 +-
 src/coreclr/vm/loaderallocator.cpp            |    8 +-
 src/coreclr/vm/memberload.cpp                 |    2 +-
 src/coreclr/vm/methoditer.cpp                 |   16 +-
 src/coreclr/vm/methoditer.h                   |   13 +-
 src/coreclr/vm/multicorejit.cpp               |   25 +-
 src/coreclr/vm/nativeimage.cpp                |    2 +-
 src/coreclr/vm/nativelibrary.cpp              |    8 +-
 src/coreclr/vm/peassembly.cpp                 |    4 +-
 src/coreclr/vm/peassembly.h                   |   11 +-
 src/coreclr/vm/perfmap.cpp                    |    2 +-
 src/coreclr/vm/prestub.cpp                    |    2 +-
 src/coreclr/vm/profilingenumerators.cpp       |   29 +-
 src/coreclr/vm/proftoeeinterfaceimpl.cpp      |    2 +-
 src/coreclr/vm/reflectioninvocation.cpp       |   10 +-
 src/coreclr/vm/rejit.cpp                      |   42 +-
 src/coreclr/vm/runtimehandles.cpp             |   20 +-
 src/coreclr/vm/threads.cpp                    |    4 +-
 src/coreclr/vm/threads.h                      |    2 +-
 src/coreclr/vm/typeparse.cpp                  |    4 +-
 src/coreclr/vm/zapsig.cpp                     |    4 +-
 77 files changed, 1743 insertions(+), 2452 deletions(-)
 rename src/coreclr/vm/{domainfile.cpp => domainassembly.cpp} (80%)
 rename src/coreclr/vm/{domainfile.h => domainassembly.h} (59%)
 delete mode 100644 src/coreclr/vm/domainfile.inl

diff --git a/src/coreclr/debug/daccess/dacdbiimpl.cpp b/src/coreclr/debug/daccess/dacdbiimpl.cpp
index 4efcd8a8323b4f..1ff143cf7cce16 100644
--- a/src/coreclr/debug/daccess/dacdbiimpl.cpp
+++ b/src/coreclr/debug/daccess/dacdbiimpl.cpp
@@ -657,21 +657,21 @@ void DacDbiInterfaceImpl::GetAppDomainFullName(
 
 // Get the values of the JIT Optimization and EnC flags.
 void DacDbiInterfaceImpl::GetCompilerFlags (
-    VMPTR_DomainFile vmDomainFile,
+    VMPTR_DomainAssembly vmDomainAssembly,
     BOOL *pfAllowJITOpts,
     BOOL *pfEnableEnC)
 {
     DD_ENTER_MAY_THROW;
 
-    DomainFile * pDomainFile = vmDomainFile.GetDacPtr();
+    DomainAssembly * pDomainAssembly = vmDomainAssembly.GetDacPtr();
 
-    if (pDomainFile == NULL)
+    if (pDomainAssembly == NULL)
     {
         ThrowHR(E_FAIL);
     }
 
     // Get the underlying module - none of this is AppDomain specific
-    Module * pModule = pDomainFile->GetModule();
+    Module * pModule = pDomainAssembly->GetModule();
     DWORD dwBits = pModule->GetDebuggerInfoBits();
     *pfAllowJITOpts = !CORDisableJITOptimizations(dwBits);
     *pfEnableEnC = pModule->IsEditAndContinueEnabled();
@@ -712,15 +712,15 @@ bool DacDbiInterfaceImpl::CanSetEnCBits(Module * pModule)
 } // DacDbiInterfaceImpl::SetEnCBits
 
 // Set the values of the JIT optimization and EnC flags.
-HRESULT DacDbiInterfaceImpl::SetCompilerFlags(VMPTR_DomainFile vmDomainFile,
+HRESULT DacDbiInterfaceImpl::SetCompilerFlags(VMPTR_DomainAssembly vmDomainAssembly,
                                            BOOL             fAllowJitOpts,
                                            BOOL             fEnableEnC)
 {
     DD_ENTER_MAY_THROW;
 
     DWORD        dwBits      = 0;
-    DomainFile * pDomainFile = vmDomainFile.GetDacPtr();
-    Module *     pModule     = pDomainFile->GetCurrentModule();
+    DomainAssembly * pDomainAssembly = vmDomainAssembly.GetDacPtr();
+    Module *     pModule     = pDomainAssembly->GetModule();
     HRESULT      hr          = S_OK;
 
 
@@ -1082,15 +1082,15 @@ ULONG DacDbiInterfaceImpl::TranslateInstrumentedILOffsetToOriginal(ULONG
 // a module and a token. The info will come from a MethodDesc, if
 // one exists or from metadata.
 //
-void DacDbiInterfaceImpl::GetILCodeAndSig(VMPTR_DomainFile vmDomainFile,
+void DacDbiInterfaceImpl::GetILCodeAndSig(VMPTR_DomainAssembly vmDomainAssembly,
                                           mdToken          functionToken,
                                           TargetBuffer *   pCodeInfo,
                                           mdToken *        pLocalSigToken)
 {
     DD_ENTER_MAY_THROW;
 
-    DomainFile * pDomainFile = vmDomainFile.GetDacPtr();
-    Module *     pModule     = pDomainFile->GetCurrentModule();
+    DomainAssembly * pDomainAssembly = vmDomainAssembly.GetDacPtr();
+    Module *     pModule     = pDomainAssembly->GetModule();
     RVA          methodRVA   = 0;
     DWORD        implFlags;
 
@@ -1323,7 +1323,7 @@ void DacDbiInterfaceImpl::GetMethodRegionInfo(MethodDesc *             pMethodDe
 // isn't currently available. In this case, all values in pCodeInfo will be
 // cleared.
 
-void DacDbiInterfaceImpl::GetNativeCodeInfo(VMPTR_DomainFile         vmDomainFile,
+void DacDbiInterfaceImpl::GetNativeCodeInfo(VMPTR_DomainAssembly         vmDomainAssembly,
                                             mdToken                  functionToken,
                                             NativeCodeFunctionData * pCodeInfo)
 {
@@ -1334,8 +1334,8 @@ void DacDbiInterfaceImpl::GetNativeCodeInfo(VMPTR_DomainFile         vmDomainFil
     // pre-initialize:
     pCodeInfo->Clear();
 
-    DomainFile * pDomainFile = vmDomainFile.GetDacPtr();
-    Module *     pModule     = pDomainFile->GetCurrentModule();
+    DomainAssembly * pDomainAssembly = vmDomainAssembly.GetDacPtr();
+    Module *     pModule     = pDomainAssembly->GetModule();
 
     MethodDesc* pMethodDesc = FindLoadedMethodRefOrDef(pModule, functionToken);
     pCodeInfo->vmNativeCodeMethodDescToken.SetHostPtr(pMethodDesc);
@@ -1760,7 +1760,7 @@ void DacDbiInterfaceImpl::GetClassInfo(VMPTR_AppDomain  vmAppDomain,
 } // DacDbiInterfaceImpl::GetClassInfo
 
 // DacDbi API: Get field information and object size for an instantiated generic type
-void DacDbiInterfaceImpl::GetInstantiationFieldInfo (VMPTR_DomainFile             vmDomainFile,
+void DacDbiInterfaceImpl::GetInstantiationFieldInfo (VMPTR_DomainAssembly             vmDomainAssembly,
                                                      VMPTR_TypeHandle             vmThExact,
                                                      VMPTR_TypeHandle             vmThApprox,
                                                      DacDbiArrayList<FieldData> * pFieldList,
@@ -1768,9 +1768,9 @@ void DacDbiInterfaceImpl::GetInstantiationFieldInfo (VMPTR_DomainFile
 {
     DD_ENTER_MAY_THROW;
 
-    DomainFile * pDomainFile = vmDomainFile.GetDacPtr();
-    _ASSERTE(pDomainFile != NULL);
-    AppDomain * pAppDomain = pDomainFile->GetAppDomain();
+    DomainAssembly * pDomainAssembly = vmDomainAssembly.GetDacPtr();
+    _ASSERTE(pDomainAssembly != NULL);
+    AppDomain * pAppDomain = pDomainAssembly->GetAppDomain();
     TypeHandle  thExact;
     TypeHandle  thApprox;
 
@@ -2503,11 +2503,11 @@ void DacDbiInterfaceImpl::GetClassTypeInfo(TypeHandle                      typeH
     pTypeInfo->ClassTypeData.vmModule.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule));
     if (pAppDomain)
     {
-        pTypeInfo->ClassTypeData.vmDomainFile.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule->GetDomainFile()));
+        pTypeInfo->ClassTypeData.vmDomainAssembly.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule->GetDomainAssembly()));
     }
     else
     {
-        pTypeInfo->ClassTypeData.vmDomainFile = VMPTR_DomainFile::NullPtr();
+        pTypeInfo->ClassTypeData.vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
     }
 } // DacDbiInterfaceImpl::GetClassTypeInfo
 
@@ -2567,7 +2567,7 @@ void DacDbiInterfaceImpl::TypeHandleToBasicTypeInfo(TypeHandle
         case ELEMENT_TYPE_BYREF:
             pTypeInfo->vmTypeHandle.SetDacTargetPtr(typeHandle.AsTAddr());
             pTypeInfo->metadataToken = mdTokenNil;
-            pTypeInfo->vmDomainFile = VMPTR_DomainFile::NullPtr();
+            pTypeInfo->vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
             break;
 
         case ELEMENT_TYPE_CLASS:
@@ -2590,11 +2590,11 @@ void DacDbiInterfaceImpl::TypeHandleToBasicTypeInfo(TypeHandle
             pTypeInfo->vmModule.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule));
             if (pAppDomain)
             {
-                pTypeInfo->vmDomainFile.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule->GetDomainFile()));
+                pTypeInfo->vmDomainAssembly.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule->GetDomainAssembly()));
             }
             else
             {
-                pTypeInfo->vmDomainFile = VMPTR_DomainFile::NullPtr();
+                pTypeInfo->vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
             }
             break;
         }
@@ -2602,7 +2602,7 @@ void DacDbiInterfaceImpl::TypeHandleToBasicTypeInfo(TypeHandle
         default:
             pTypeInfo->vmTypeHandle = VMPTR_TypeHandle::NullPtr();
             pTypeInfo->metadataToken = mdTokenNil;
-            pTypeInfo->vmDomainFile = VMPTR_DomainFile::NullPtr();
+            pTypeInfo->vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
             break;
     }
     return;
@@ -2889,8 +2889,8 @@ TypeHandle DacDbiInterfaceImpl::GetClassOrValueTypeHandle(DebuggerIPCE_BasicType
     // otherwise, have the loader look it up using the metadata token and domain file
     else
     {
-        DomainFile * pDomainFile = pData->vmDomainFile.GetDacPtr();
-        Module *     pModule = pDomainFile->GetModule();
+        DomainAssembly * pDomainAssembly = pData->vmDomainAssembly.GetDacPtr();
+        Module *     pModule = pDomainAssembly->GetModule();
 
         typeHandle = ClassLoader::LookupTypeDefOrRefInModule(pModule, pData->metadataToken);
         if (typeHandle.IsNull())
@@ -3292,7 +3292,7 @@ void DacDbiInterfaceImpl::GetSimpleType(VMPTR_AppDomain    vmAppDomain,
                                         CorElementType     simpleType,
                                         mdTypeDef         *pMetadataToken,
                                         VMPTR_Module      *pVmModule,
-                                        VMPTR_DomainFile  *pVmDomainFile)
+                                        VMPTR_DomainAssembly  *pVmDomainAssembly)
 {
     DD_ENTER_MAY_THROW;
 
@@ -3300,8 +3300,8 @@ void DacDbiInterfaceImpl::GetSimpleType(VMPTR_AppDomain    vmAppDomain,
 
     // if we fail to get either a valid type handle or module, we will want to send back
     // a NULL domain file too, so we'll to preinitialize this here.
-    _ASSERTE(pVmDomainFile != NULL);
-    *pVmDomainFile = VMPTR_DomainFile::NullPtr();
+    _ASSERTE(pVmDomainAssembly != NULL);
+    *pVmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
     // FindLoadedElementType will return NULL if the type hasn't been loaded yet.
     TypeHandle typeHandle =  FindLoadedElementType(simpleType);
 
@@ -3322,8 +3322,8 @@ void DacDbiInterfaceImpl::GetSimpleType(VMPTR_AppDomain    vmAppDomain,
 
         if (pAppDomain)
         {
-            pVmDomainFile->SetHostPtr(pModule->GetDomainFile());
-            if (pVmDomainFile->IsNull())
+            pVmDomainAssembly->SetHostPtr(pModule->GetDomainAssembly());
+            if (pVmDomainAssembly->IsNull())
                 ThrowHR(CORDBG_E_TARGET_INCONSISTENT);
         }
     }
@@ -3483,7 +3483,7 @@ HRESULT DacDbiInterfaceImpl::GetDelegateType(VMPTR_Object delegateObject, Delega
 HRESULT DacDbiInterfaceImpl::GetDelegateFunctionData(
     DelegateType delegateType,
     VMPTR_Object delegateObject,
-    OUT VMPTR_DomainFile *ppFunctionDomainFile,
+    OUT VMPTR_DomainAssembly *ppFunctionDomainAssembly,
     OUT mdMethodDef *pMethodDef)
 {
     DD_ENTER_MAY_THROW;
@@ -3514,7 +3514,7 @@ HRESULT DacDbiInterfaceImpl::GetDelegateFunctionData(
     if (hr != S_OK)
         return hr;
 
-    ppFunctionDomainFile->SetDacTargetPtr(dac_cast<TADDR>(pMD.GetDacPtr()->GetModule()->GetDomainFile()));
+    ppFunctionDomainAssembly->SetDacTargetPtr(dac_cast<TADDR>(pMD.GetDacPtr()->GetModule()->GetDomainAssembly()));
     *pMethodDef = pMD.GetDacPtr()->GetMemberDef();
 
     return hr;
@@ -3725,17 +3725,17 @@ void DacDbiInterfaceImpl::GetStackFramesFromException(VMPTR_Object vmObject, Dac
             BaseDomain* pBaseDomain = currentElement.pFunc->GetAssembly()->GetDomain();
 
             AppDomain* pDomain = NULL;
-            DomainFile* pDomainFile = NULL;
+            DomainAssembly* pDomainAssembly = NULL;
 
             pDomain = pBaseDomain->AsAppDomain();
 
             _ASSERTE(pDomain != NULL);
 
-            pDomainFile = pModule->GetDomainFile();
-            _ASSERTE(pDomainFile != NULL);
+            pDomainAssembly = pModule->GetDomainAssembly();
+            _ASSERTE(pDomainAssembly != NULL);
 
             currentFrame.vmAppDomain.SetHostPtr(pDomain);
-            currentFrame.vmDomainFile.SetHostPtr(pDomainFile);
+            currentFrame.vmDomainAssembly.SetHostPtr(pDomainAssembly);
             currentFrame.ip = currentElement.ip;
             currentFrame.methodDef = currentElement.pFunc->GetMemberDef();
             currentFrame.isLastForeignExceptionFrame = (currentElement.flags & STEF_LAST_FRAME_FROM_FOREIGN_STACK_TRACE) != 0;
@@ -3879,8 +3879,8 @@ FieldDesc * DacDbiInterfaceImpl::GetEnCFieldDesc(const EnCHangingFieldInfo * pEn
 {
         FieldDesc * pFD = NULL;
 
-        DomainFile * pDomainFile = pEnCFieldInfo->GetObjectTypeData().vmDomainFile.GetDacPtr();
-        Module     * pModule     = pDomainFile->GetModule();
+        DomainAssembly * pDomainAssembly = pEnCFieldInfo->GetObjectTypeData().vmDomainAssembly.GetDacPtr();
+        Module     * pModule     = pDomainAssembly->GetModule();
 
         // get the type handle for the object
         TypeHandle typeHandle = ClassLoader::LookupTypeDefOrRefInModule(pModule,
@@ -3918,8 +3918,8 @@ PTR_CBYTE DacDbiInterfaceImpl::GetPtrToEnCField(FieldDesc * pFD, const EnCHangin
 #else
 
     PTR_EditAndContinueModule pEnCModule;
-    DomainFile * pDomainFile = pEnCFieldInfo->GetObjectTypeData().vmDomainFile.GetDacPtr();
-    Module     * pModule     = pDomainFile->GetModule();
+    DomainAssembly * pDomainAssembly = pEnCFieldInfo->GetObjectTypeData().vmDomainAssembly.GetDacPtr();
+    Module     * pModule     = pDomainAssembly->GetModule();
 
     // make sure we actually have an EditAndContinueModule
     _ASSERTE(pModule->IsEditAndContinueCapable());
@@ -4066,7 +4066,7 @@ BOOL DacDbiInterfaceImpl::GetAssemblyPath(
 
     // Get the manifest module for this assembly
     Assembly * pAssembly = vmAssembly.GetDacPtr();
-    Module * pManifestModule = pAssembly->GetManifestModule();
+    Module * pManifestModule = pAssembly->GetModule();
 
     // Get the path for the manifest module.
     // since we no longer support Win9x, we assume all paths will be in unicode format already
@@ -4090,8 +4090,8 @@ void DacDbiInterfaceImpl::ResolveTypeReference(const TypeRefData * pTypeRefInfo,
                                                TypeRefData *       pTargetRefInfo)
 {
     DD_ENTER_MAY_THROW;
-    DomainFile * pDomainFile        = pTypeRefInfo->vmDomainFile.GetDacPtr();
-    Module *     pReferencingModule = pDomainFile->GetCurrentModule();
+    DomainAssembly * pDomainAssembly        = pTypeRefInfo->vmDomainAssembly.GetDacPtr();
+    Module *     pReferencingModule = pDomainAssembly->GetModule();
     BOOL         fSuccess = FALSE;
 
     // Resolve the type ref
@@ -4117,9 +4117,9 @@ void DacDbiInterfaceImpl::ResolveTypeReference(const TypeRefData * pTypeRefInfo,
         _ASSERTE(pTargetModule != NULL);
         _ASSERTE( TypeFromToken(targetTypeDef) == mdtTypeDef );
 
-        AppDomain * pAppDomain = pDomainFile->GetAppDomain();
+        AppDomain * pAppDomain = pDomainAssembly->GetAppDomain();
 
-        pTargetRefInfo->vmDomainFile.SetDacTargetPtr(PTR_HOST_TO_TADDR(pTargetModule->GetDomainFile()));
+        pTargetRefInfo->vmDomainAssembly.SetDacTargetPtr(PTR_HOST_TO_TADDR(pTargetModule->GetDomainAssembly()));
         pTargetRefInfo->typeToken = targetTypeDef;
     }
     else
@@ -4347,19 +4347,19 @@ void DacDbiInterfaceImpl::GetSymbolsBuffer(VMPTR_Module vmModule, TargetBuffer *
 
 
 
-void DacDbiInterfaceImpl::GetModuleForDomainFile(VMPTR_DomainFile vmDomainFile, OUT VMPTR_Module * pModule)
+void DacDbiInterfaceImpl::GetModuleForDomainAssembly(VMPTR_DomainAssembly vmDomainAssembly, OUT VMPTR_Module * pModule)
 {
     DD_ENTER_MAY_THROW;
 
     _ASSERTE(pModule != NULL);
 
-    DomainFile * pDomainFile = vmDomainFile.GetDacPtr();
-    pModule->SetHostPtr(pDomainFile->GetModule());
+    DomainAssembly * pDomainAssembly = vmDomainAssembly.GetDacPtr();
+    pModule->SetHostPtr(pDomainAssembly->GetModule());
 }
 
 
-// Implement IDacDbiInterface::GetDomainFileData
-void DacDbiInterfaceImpl::GetDomainFileData(VMPTR_DomainFile vmDomainFile, DomainFileInfo * pData)
+// Implement IDacDbiInterface::GetDomainAssemblyData
+void DacDbiInterfaceImpl::GetDomainAssemblyData(VMPTR_DomainAssembly vmDomainAssembly, DomainAssemblyInfo * pData)
 {
     DD_ENTER_MAY_THROW;
 
@@ -4367,12 +4367,11 @@ void DacDbiInterfaceImpl::GetDomainFileData(VMPTR_DomainFile vmDomainFile, Domai
 
     ZeroMemory(pData, sizeof(*pData));
 
-    DomainFile * pDomainFile  = vmDomainFile.GetDacPtr();
-    AppDomain  * pAppDomain   = pDomainFile->GetAppDomain();
+    DomainAssembly * pDomainAssembly  = vmDomainAssembly.GetDacPtr();
+    AppDomain  * pAppDomain   = pDomainAssembly->GetAppDomain();
 
     // @dbgtodo - is this efficient DAC usage (perhaps a dac-cop rule)? Are we round-tripping the pointer?
-    // Should we have a GetDomainAssembly() that returns a PTR_DomainAssembly?
-    pData->vmDomainAssembly.SetHostPtr(pDomainFile->GetDomainAssembly());
+    pData->vmDomainAssembly.SetHostPtr(pDomainAssembly);
     pData->vmAppDomain.SetHostPtr(pAppDomain);
 }
 
@@ -4494,41 +4493,30 @@ void DacDbiInterfaceImpl::EnumerateModulesInAssembly(
 
     DomainAssembly * pDomainAssembly = vmAssembly.GetDacPtr();
 
-    // If the domain is not yet fully-loaded, don't advertise it yet.
-    // It's not ready to be inspected.
-    DomainModuleIterator iterator =  pDomainAssembly->IterateModules(kModIterIncludeLoaded);
-
-    while (iterator.Next())
+    // Debugger isn't notified of Resource / Inspection-only modules.
+    if (pDomainAssembly->GetModule()->IsVisibleToDebugger())
     {
-        DomainFile * pDomainFile = iterator.GetDomainFile();
+        _ASSERTE(pDomainAssembly->IsLoaded());
 
-        // Debugger isn't notified of Resource / Inspection-only modules.
-        if (!pDomainFile->GetModule()->IsVisibleToDebugger())
-        {
-            continue;
-        }
-
-        _ASSERTE(pDomainFile->IsLoaded());
-
-        VMPTR_DomainFile vmDomainFile = VMPTR_DomainFile::NullPtr();
-        vmDomainFile.SetHostPtr(pDomainFile);
+        VMPTR_DomainAssembly vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
+        vmDomainAssembly.SetHostPtr(pDomainAssembly);
 
-        fpCallback(vmDomainFile, pUserData);
+        fpCallback(vmDomainAssembly, pUserData);
     }
 }
 
 // Implementation of IDacDbiInterface::ResolveAssembly
 // Returns NULL if not found.
 VMPTR_DomainAssembly DacDbiInterfaceImpl::ResolveAssembly(
-    VMPTR_DomainFile vmScope,
+    VMPTR_DomainAssembly vmScope,
     mdToken tkAssemblyRef)
 {
     DD_ENTER_MAY_THROW;
 
 
-    DomainFile * pDomainFile  = vmScope.GetDacPtr();
-    AppDomain  * pAppDomain   = pDomainFile->GetAppDomain();
-    Module     * pModule      = pDomainFile->GetCurrentModule();
+    DomainAssembly * pDomainAssembly  = vmScope.GetDacPtr();
+    AppDomain  * pAppDomain   = pDomainAssembly->GetAppDomain();
+    Module     * pModule      = pDomainAssembly->GetModule();
 
     VMPTR_DomainAssembly vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
 
@@ -6068,7 +6056,7 @@ void DacDbiInterfaceImpl::GetTypedByRefInfo(CORDB_ADDRESS             pTypedByRe
          "ref=0x%08x, cls=0x%08x, mod=0x%p\n",
          pObjectData->objRef,
          pObjectData->typedByrefType.metadataToken,
-         pObjectData->typedByrefType.vmDomainFile.GetDacPtr()));
+         pObjectData->typedByrefType.vmDomainAssembly.GetDacPtr()));
 } // DacDbiInterfaceImpl::GetTypedByRefInfo
 
 // Get the string data associated withn obj and put it into the pointers
@@ -7025,7 +7013,7 @@ bool DacDbiInterfaceImpl::IsValidObject(CORDB_ADDRESS addr)
 }
 
 bool DacDbiInterfaceImpl::GetAppDomainForObject(CORDB_ADDRESS addr, OUT VMPTR_AppDomain * pAppDomain,
-                                                OUT VMPTR_Module *pModule, OUT VMPTR_DomainFile *pDomainFile)
+                                                OUT VMPTR_Module *pModule, OUT VMPTR_DomainAssembly *pDomainAssembly)
 {
     DD_ENTER_MAY_THROW;
 
@@ -7045,7 +7033,7 @@ bool DacDbiInterfaceImpl::GetAppDomainForObject(CORDB_ADDRESS addr, OUT VMPTR_Ap
     {
         pAppDomain->SetDacTargetPtr(PTR_HOST_TO_TADDR(baseDomain->AsAppDomain()));
         pModule->SetDacTargetPtr(PTR_HOST_TO_TADDR(module));
-        pDomainFile->SetDacTargetPtr(PTR_HOST_TO_TADDR(module->GetDomainFile()));
+        pDomainAssembly->SetDacTargetPtr(PTR_HOST_TO_TADDR(module->GetDomainAssembly()));
     }
     else
     {
diff --git a/src/coreclr/debug/daccess/dacdbiimpl.h b/src/coreclr/debug/daccess/dacdbiimpl.h
index e484a28008b0cf..e885703113197e 100644
--- a/src/coreclr/debug/daccess/dacdbiimpl.h
+++ b/src/coreclr/debug/daccess/dacdbiimpl.h
@@ -96,7 +96,7 @@ class DacDbiInterfaceImpl :
         IStringHolder * pStrName);
 
     // Get the values of the JIT Optimization and EnC flags.
-    void GetCompilerFlags (VMPTR_DomainFile vmDomainFile,
+    void GetCompilerFlags (VMPTR_DomainAssembly vmDomainAssembly,
                            BOOL * pfAllowJITOpts,
                            BOOL * pfEnableEnC);
 
@@ -104,7 +104,7 @@ class DacDbiInterfaceImpl :
     bool CanSetEnCBits(Module * pModule);
 
     // Set the values of the JIT optimization and EnC flags.
-    HRESULT SetCompilerFlags(VMPTR_DomainFile vmDomainFile,
+    HRESULT SetCompilerFlags(VMPTR_DomainAssembly vmDomainAssembly,
                              BOOL             fAllowJitOpts,
                              BOOL             fEnableEnC);
 
@@ -133,7 +133,7 @@ class DacDbiInterfaceImpl :
 
     bool IsValidObject(CORDB_ADDRESS obj);
 
-    bool GetAppDomainForObject(CORDB_ADDRESS obj, OUT VMPTR_AppDomain * pApp, OUT VMPTR_Module *pModule, OUT VMPTR_DomainFile *mod);
+    bool GetAppDomainForObject(CORDB_ADDRESS obj, OUT VMPTR_AppDomain * pApp, OUT VMPTR_Module *pModule, OUT VMPTR_DomainAssembly *mod);
 
 
 
@@ -218,7 +218,7 @@ class DacDbiInterfaceImpl :
     // a module and a token. The info will come from a MethodDesc, if
     // one exists or from metadata.
     //
-    void GetILCodeAndSig(VMPTR_DomainFile vmDomainFile,
+    void GetILCodeAndSig(VMPTR_DomainAssembly vmDomainAssembly,
                          mdToken          functionToken,
                          TargetBuffer *   pCodeInfo,
                          mdToken *        pLocalSigToken);
@@ -229,7 +229,7 @@ class DacDbiInterfaceImpl :
     //    whether it's an instantiated generic
     //    its EnC version number
     //    hot and cold region information.
-    void GetNativeCodeInfo(VMPTR_DomainFile         vmDomainFile,
+    void GetNativeCodeInfo(VMPTR_DomainAssembly         vmDomainAssembly,
                            mdToken                  functionToken,
                            NativeCodeFunctionData * pCodeInfo);
 
@@ -260,7 +260,7 @@ class DacDbiInterfaceImpl :
                        ClassInfo *      pData);
 
     // get field information and object size for an instantiated generic type
-    void GetInstantiationFieldInfo (VMPTR_DomainFile             vmDomainFile,
+    void GetInstantiationFieldInfo (VMPTR_DomainAssembly             vmDomainAssembly,
                                     VMPTR_TypeHandle             vmThExact,
                                     VMPTR_TypeHandle             vmThApprox,
                                     DacDbiArrayList<FieldData> * pFieldList,
@@ -336,7 +336,7 @@ class DacDbiInterfaceImpl :
                        CorElementType     simpleType,
                        mdTypeDef *        pMetadataToken,
                        VMPTR_Module     * pVmModule,
-                       VMPTR_DomainFile * pVmDomainFile);
+                       VMPTR_DomainAssembly * pVmDomainAssembly);
 
     BOOL IsExceptionObject(VMPTR_Object vmObject);
 
@@ -352,7 +352,7 @@ class DacDbiInterfaceImpl :
     HRESULT GetDelegateFunctionData(
         DelegateType delegateType,
         VMPTR_Object delegateObject,
-        OUT VMPTR_DomainFile *ppFunctionDomainFile,
+        OUT VMPTR_DomainAssembly *ppFunctionDomainAssembly,
         OUT mdMethodDef *pMethodDef);
 
     HRESULT GetDelegateTargetObject(
@@ -730,10 +730,10 @@ class DacDbiInterfaceImpl :
     // Gets properties for a module
     void GetModuleData(VMPTR_Module vmModule, ModuleInfo * pData);
 
-    // Gets properties for a domainfile
-    void GetDomainFileData(VMPTR_DomainFile vmDomainFile, DomainFileInfo * pData);
+    // Gets properties for a domain assembly
+    void GetDomainAssemblyData(VMPTR_DomainAssembly vmDomainAssembly, DomainAssemblyInfo * pData);
 
-    void GetModuleForDomainFile(VMPTR_DomainFile vmDomainFile, OUT VMPTR_Module * pModule);
+    void GetModuleForDomainAssembly(VMPTR_DomainAssembly vmDomainAssembly, OUT VMPTR_Module * pModule);
 
     // Yields true if the address is a CLR stub.
     BOOL IsTransitionStub(CORDB_ADDRESS address);
@@ -829,8 +829,8 @@ class DacDbiInterfaceImpl :
     // Return the current appdomain the specified thread is in.
     VMPTR_AppDomain GetCurrentAppDomain(VMPTR_Thread vmThread);
 
-    // Given an assembly ref token and metadata scope (via the DomainFile), resolve the assembly.
-    VMPTR_DomainAssembly ResolveAssembly(VMPTR_DomainFile vmScope, mdToken tkAssemblyRef);
+    // Given an assembly ref token and metadata scope (via the DomainAssembly), resolve the assembly.
+    VMPTR_DomainAssembly ResolveAssembly(VMPTR_DomainAssembly vmScope, mdToken tkAssemblyRef);
 
 
     // Hijack the thread
diff --git a/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp b/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp
index 251b5dde74fdfc..b8a84043b396f9 100644
--- a/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp
+++ b/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp
@@ -514,7 +514,7 @@ void DacDbiInterfaceImpl::EnumerateInternalFrames(VMPTR_Thread
 #endif // FEATURE_COMINTEROP
 
             Module *     pModule = (pMD ? pMD->GetModule() : NULL);
-            DomainFile * pDomainFile = (pModule ? pModule->GetDomainFile() : NULL);
+            DomainAssembly * pDomainAssembly = (pModule ? pModule->GetDomainAssembly() : NULL);
 
             if (frameData.stubFrame.frameType == STUBFRAME_FUNC_EVAL)
             {
@@ -522,14 +522,14 @@ void DacDbiInterfaceImpl::EnumerateInternalFrames(VMPTR_Thread
                 DebuggerEval *  pDE  = pFEF->GetDebuggerEval();
 
                 frameData.stubFrame.funcMetadataToken = pDE->m_methodToken;
-                frameData.stubFrame.vmDomainFile.SetHostPtr(
-                    pDE->m_debuggerModule ? pDE->m_debuggerModule->GetDomainFile() : NULL);
+                frameData.stubFrame.vmDomainAssembly.SetHostPtr(
+                    pDE->m_debuggerModule ? pDE->m_debuggerModule->GetDomainAssembly() : NULL);
                 frameData.stubFrame.vmMethodDesc = VMPTR_MethodDesc::NullPtr();
             }
             else
             {
                 frameData.stubFrame.funcMetadataToken = (pMD == NULL ? NULL : pMD->GetMemberDef());
-                frameData.stubFrame.vmDomainFile.SetHostPtr(pDomainFile);
+                frameData.stubFrame.vmDomainAssembly.SetHostPtr(pDomainAssembly);
                 frameData.stubFrame.vmMethodDesc.SetHostPtr(pMD);
             }
 
@@ -702,11 +702,11 @@ void DacDbiInterfaceImpl::InitFrameData(StackFrameIterator *   pIter,
         // Although MiniDumpNormal tries to dump all AppDomains, it's possible
         // target corruption will keep one from being present.  This should mean
         // we'll just fail later, but struggle on for now.
-        DomainFile *pDomainFile = NULL;
+        DomainAssembly *pDomainAssembly = NULL;
         EX_TRY_ALLOW_DATATARGET_MISSING_MEMORY
         {
-            pDomainFile = (pModule ? pModule->GetDomainFile() : NULL);
-            _ASSERTE(pDomainFile != NULL);
+            pDomainAssembly = (pModule ? pModule->GetDomainAssembly() : NULL);
+            _ASSERTE(pDomainAssembly != NULL);
         }
         EX_END_CATCH_ALLOW_DATATARGET_MISSING_MEMORY
 
@@ -783,7 +783,7 @@ void DacDbiInterfaceImpl::InitFrameData(StackFrameIterator *   pIter,
         //
 
         pFuncData->funcMetadataToken = pMD->GetMemberDef();
-        pFuncData->vmDomainFile.SetHostPtr(pDomainFile);
+        pFuncData->vmDomainAssembly.SetHostPtr(pDomainAssembly);
 
         // PERF: this is expensive to get so I stopped fetching it eagerly
         // It is only needed if we haven't already got a cached copy
diff --git a/src/coreclr/debug/daccess/dacimpl.h b/src/coreclr/debug/daccess/dacimpl.h
index 318d88be4d0085..7a03d984e3ac70 100644
--- a/src/coreclr/debug/daccess/dacimpl.h
+++ b/src/coreclr/debug/daccess/dacimpl.h
@@ -506,7 +506,6 @@ struct ProcessModIter
     bool m_nextDomain;
     AppDomain::AssemblyIterator m_assemIter;
     Assembly* m_curAssem;
-    Assembly::ModuleIterator m_modIter;
 
     ProcessModIter(void)
         : m_domainIter(FALSE)
@@ -542,7 +541,7 @@ struct ProcessModIter
             }
 
             // Note: DAC doesn't need to keep the assembly alive - see code:CollectibleAssemblyHolder#CAH_DAC
-            CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetLoadedAssembly();
+            CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetAssembly();
             return pAssembly;
         }
         return NULL;
@@ -551,27 +550,13 @@ struct ProcessModIter
     Module* NextModule(void)
     {
         SUPPORTS_DAC;
-        for (;;)
+        m_curAssem = NextAssem();
+        if (!m_curAssem)
         {
-            if (!m_curAssem)
-            {
-                m_curAssem = NextAssem();
-                if (!m_curAssem)
-                {
-                    return NULL;
-                }
-
-                m_modIter = m_curAssem->IterateModules();
-            }
-
-            if (!m_modIter.Next())
-            {
-                m_curAssem = NULL;
-                continue;
-            }
-
-            return m_modIter.GetModule();
+            return NULL;
         }
+
+        return m_curAssem->GetModule();
     }
 };
 
diff --git a/src/coreclr/debug/daccess/request.cpp b/src/coreclr/debug/daccess/request.cpp
index 1e327721f4a92d..cd81cde5ac69ee 100644
--- a/src/coreclr/debug/daccess/request.cpp
+++ b/src/coreclr/debug/daccess/request.cpp
@@ -2607,10 +2607,7 @@ ClrDataAccess::GetAssemblyData(CLRDATA_ADDRESS cdBaseDomainPtr, CLRDATA_ADDRESS
     assemblyData->ModuleCount = 0;
     assemblyData->isDomainNeutral = FALSE;
 
-    pAssembly->GetManifestFile();
-
-    ModuleIterator mi = pAssembly->IterateModules();
-    while (mi.Next())
+    if (pAssembly->GetModule())
     {
         assemblyData->ModuleCount++;
     }
@@ -2628,17 +2625,17 @@ ClrDataAccess::GetAssemblyName(CLRDATA_ADDRESS assembly, unsigned int count, _In
     if (name)
         name[0] = 0;
 
-    if (!pAssembly->GetManifestFile()->GetPath().IsEmpty())
+    if (!pAssembly->GetPEAssembly()->GetPath().IsEmpty())
     {
-        if (!pAssembly->GetManifestFile()->GetPath().DacGetUnicode(count, name, pNeeded))
+        if (!pAssembly->GetPEAssembly()->GetPath().DacGetUnicode(count, name, pNeeded))
             hr = E_FAIL;
         else if (name)
             name[count-1] = 0;
     }
-    else if (!pAssembly->GetManifestFile()->IsDynamic())
+    else if (!pAssembly->GetPEAssembly()->IsDynamic())
     {
         StackSString displayName;
-        pAssembly->GetManifestFile()->GetDisplayName(displayName, 0);
+        pAssembly->GetPEAssembly()->GetDisplayName(displayName, 0);
 
         const WCHAR *val = displayName.GetUnicode();
 
@@ -2673,9 +2670,9 @@ ClrDataAccess::GetAssemblyLocation(CLRDATA_ADDRESS assembly, int count, _Inout_u
     Assembly* pAssembly = PTR_Assembly(TO_TADDR(assembly));
 
     // Turn from bytes to wide characters
-    if (!pAssembly->GetManifestFile()->GetPath().IsEmpty())
+    if (!pAssembly->GetPEAssembly()->GetPath().IsEmpty())
     {
-        if (!pAssembly->GetManifestFile()->GetPath().
+        if (!pAssembly->GetPEAssembly()->GetPath().
             DacGetUnicode(count, location, pNeeded))
         {
             hr = E_FAIL;
@@ -2703,21 +2700,14 @@ ClrDataAccess::GetAssemblyModuleList(CLRDATA_ADDRESS assembly, unsigned int coun
     SOSDacEnter();
 
     Assembly* pAssembly = PTR_Assembly(TO_TADDR(assembly));
-    ModuleIterator mi = pAssembly->IterateModules();
-    unsigned int n = 0;
     if (modules)
     {
-        while (mi.Next() && n < count)
-            modules[n++] = HOST_CDADDR(mi.GetModule());
-    }
-    else
-    {
-        while (mi.Next())
-            n++;
+        if (pAssembly->GetModule() && count > 0)
+            modules[0] = HOST_CDADDR(pAssembly->GetModule());
     }
 
     if (pNeeded)
-        *pNeeded = n;
+        *pNeeded = 1;
 
     SOSDacLeave();
     return hr;
diff --git a/src/coreclr/debug/daccess/task.cpp b/src/coreclr/debug/daccess/task.cpp
index 30abc5e090cc9e..319d3506b9b889 100644
--- a/src/coreclr/debug/daccess/task.cpp
+++ b/src/coreclr/debug/daccess/task.cpp
@@ -948,6 +948,11 @@ ClrDataAssembly::Release(THIS)
     return newRefs;
 }
 
+struct TrivialModuleIterator
+{
+    Module* m_module;
+};
+
 HRESULT STDMETHODCALLTYPE
 ClrDataAssembly::StartEnumModules(
     /* [out] */ CLRDATA_ENUM* handle)
@@ -958,11 +963,10 @@ ClrDataAssembly::StartEnumModules(
 
     EX_TRY
     {
-        Assembly::ModuleIterator* iter = new (nothrow)
-            Assembly::ModuleIterator;
+        TrivialModuleIterator* iter = new (nothrow) TrivialModuleIterator;
         if (iter)
         {
-            *iter = m_assembly->IterateModules();
+            iter->m_module = m_assembly->GetModule();
             *handle = TO_CDENUM(iter);
             status = S_OK;
         }
@@ -995,12 +999,13 @@ ClrDataAssembly::EnumModule(
 
     EX_TRY
     {
-        Assembly::ModuleIterator* iter =
-            FROM_CDENUM(Assembly::ModuleIterator, *handle);
-        if (iter->Next())
+        TrivialModuleIterator* iter = FROM_CDENUM(TrivialModuleIterator, *handle);
+        if (iter->m_module)
         {
             *mod = new (nothrow)
-                ClrDataModule(m_dac, iter->GetModule());
+                ClrDataModule(m_dac, iter->m_module);
+
+            iter->m_module = NULL;
             status = *mod ? S_OK : E_OUTOFMEMORY;
         }
         else
@@ -1031,8 +1036,7 @@ ClrDataAssembly::EndEnumModules(
 
     EX_TRY
     {
-        Assembly::ModuleIterator* iter =
-            FROM_CDENUM(Assembly::ModuleIterator, handle);
+        TrivialModuleIterator* iter = FROM_CDENUM(TrivialModuleIterator, handle);
         delete iter;
         status = S_OK;
     }
@@ -1170,7 +1174,7 @@ ClrDataAssembly::GetFileName(
     {
         COUNT_T _nameLen;
 
-        if (m_assembly->GetManifestFile()->GetPath().
+        if (m_assembly->GetPEAssembly()->GetPath().
             DacGetUnicode(bufLen, name, &_nameLen))
         {
             if (nameLen)
diff --git a/src/coreclr/debug/di/breakpoint.cpp b/src/coreclr/debug/di/breakpoint.cpp
index eb156c49e04d9c..ad45df5c618ace 100644
--- a/src/coreclr/debug/di/breakpoint.cpp
+++ b/src/coreclr/debug/di/breakpoint.cpp
@@ -201,7 +201,7 @@ HRESULT CordbFunctionBreakpoint::Activate(BOOL fActivate)
         pProcess->InitIPCEvent(pEvent, DB_IPCE_BREAKPOINT_ADD, true, pAppDomain->GetADToken());
 
         pEvent->BreakpointData.funcMetadataToken = m_code->GetMetadataToken();
-        pEvent->BreakpointData.vmDomainFile = m_code->GetModule()->GetRuntimeDomainFile();
+        pEvent->BreakpointData.vmDomainAssembly = m_code->GetModule()->GetRuntimeDomainAssembly();
         pEvent->BreakpointData.encVersion = m_code->GetVersion();
 
         BOOL codeIsIL = m_code->IsIL();
diff --git a/src/coreclr/debug/di/divalue.cpp b/src/coreclr/debug/di/divalue.cpp
index b8c9e745260db2..5e79a5ee1c92bc 100644
--- a/src/coreclr/debug/di/divalue.cpp
+++ b/src/coreclr/debug/di/divalue.cpp
@@ -2464,7 +2464,7 @@ HRESULT CordbObjectValue::EnumerateExceptionCallStack(ICorDebugExceptionObjectCa
             CorDebugExceptionObjectStackFrame& currentStackFrame = pStackFrames[index];
 
             CordbAppDomain* pAppDomain = GetProcess()->LookupOrCreateAppDomain(currentDacFrame.vmAppDomain);
-            CordbModule* pModule = pAppDomain->LookupOrCreateModule(currentDacFrame.vmDomainFile);
+            CordbModule* pModule = pAppDomain->LookupOrCreateModule(currentDacFrame.vmDomainAssembly);
 
             hr = pModule->QueryInterface(IID_ICorDebugModule, reinterpret_cast<void**>(&currentStackFrame.pModule));
             _ASSERTE(SUCCEEDED(hr));
@@ -2653,18 +2653,18 @@ HRESULT CordbObjectValue::GetFunctionHelper(ICorDebugFunction **ppFunction)
         return hr;
 
     mdMethodDef functionMethodDef = 0;
-    VMPTR_DomainFile functionDomainFile;
+    VMPTR_DomainAssembly functionDomainAssembly;
     NativeCodeFunctionData nativeCodeForDelFunc;
 
-    hr = pDAC->GetDelegateFunctionData(delType, pDelegateObj, &functionDomainFile, &functionMethodDef);
+    hr = pDAC->GetDelegateFunctionData(delType, pDelegateObj, &functionDomainAssembly, &functionMethodDef);
     if (hr != S_OK)
         return hr;
 
     // TODO: How to ensure results are sanitized?
     // Also, this is expensive. Do we really care that much about this?
-    pDAC->GetNativeCodeInfo(functionDomainFile, functionMethodDef, &nativeCodeForDelFunc);
+    pDAC->GetNativeCodeInfo(functionDomainAssembly, functionMethodDef, &nativeCodeForDelFunc);
 
-    RSSmartPtr<CordbModule> funcModule(GetProcess()->LookupOrCreateModule(functionDomainFile));
+    RSSmartPtr<CordbModule> funcModule(GetProcess()->LookupOrCreateModule(functionDomainAssembly));
     RSSmartPtr<CordbFunction> func;
     {
         RSLockHolder lockHolder(GetProcess()->GetProcessLock());
diff --git a/src/coreclr/debug/di/module.cpp b/src/coreclr/debug/di/module.cpp
index e173671bc85137..55f9e8a29c87de 100644
--- a/src/coreclr/debug/di/module.cpp
+++ b/src/coreclr/debug/di/module.cpp
@@ -48,17 +48,17 @@ STDAPI ReOpenMetaDataWithMemoryEx(
 //
 // Arguments:
 //    pProcess - process that this module lives in
-//    vmDomainFile - CLR cookie for module.
+//    vmDomainAssembly - CLR cookie for module.
 CordbModule::CordbModule(
     CordbProcess *     pProcess,
     VMPTR_Module        vmModule,
-    VMPTR_DomainFile    vmDomainFile)
-: CordbBase(pProcess, vmDomainFile.IsNull() ? VmPtrToCookie(vmModule) : VmPtrToCookie(vmDomainFile), enumCordbModule),
+    VMPTR_DomainAssembly    vmDomainAssembly)
+: CordbBase(pProcess, vmDomainAssembly.IsNull() ? VmPtrToCookie(vmModule) : VmPtrToCookie(vmDomainAssembly), enumCordbModule),
     m_pAssembly(0),
     m_pAppDomain(0),
     m_classes(11),
     m_functions(101),
-    m_vmDomainFile(vmDomainFile),
+    m_vmDomainAssembly(vmDomainAssembly),
     m_vmModule(vmModule),
     m_EnCCount(0),
     m_fForceMetaDataSerialize(FALSE),
@@ -84,11 +84,11 @@ CordbModule::CordbModule(
     m_fInMemory = modInfo.fInMemory;
     m_vmPEFile = modInfo.vmPEAssembly;
 
-    if (!vmDomainFile.IsNull())
+    if (!vmDomainAssembly.IsNull())
     {
-        DomainFileInfo dfInfo;
+        DomainAssemblyInfo dfInfo;
 
-        pProcess->GetDAC()->GetDomainFileData(vmDomainFile, &dfInfo); // throws
+        pProcess->GetDAC()->GetDomainAssemblyData(vmDomainAssembly, &dfInfo); // throws
 
         m_pAppDomain = pProcess->LookupOrCreateAppDomain(dfInfo.vmAppDomain);
         m_pAssembly  = m_pAppDomain->LookupOrCreateAssembly(dfInfo.vmDomainAssembly);
@@ -115,21 +115,21 @@ CordbModule::CordbModule(
 // Callback helper for code:CordbModule::DbgAssertModuleDeleted
 //
 // Arguments
-//    vmDomainFile - domain file in the enumeration
+//    vmDomainAssembly - domain file in the enumeration
 //    pUserData - pointer to the CordbModule that we just got an exit event for.
 //
-void DbgAssertModuleDeletedCallback(VMPTR_DomainFile vmDomainFile, void * pUserData)
+void DbgAssertModuleDeletedCallback(VMPTR_DomainAssembly vmDomainAssembly, void * pUserData)
 {
     CordbModule * pThis = reinterpret_cast<CordbModule *>(pUserData);
     INTERNAL_DAC_CALLBACK(pThis->GetProcess());
 
-    if (!pThis->m_vmDomainFile.IsNull())
+    if (!pThis->m_vmDomainAssembly.IsNull())
     {
-        VMPTR_DomainFile vmDomainFileDeleted = pThis->m_vmDomainFile;
+        VMPTR_DomainAssembly vmDomainAssemblyDeleted = pThis->m_vmDomainAssembly;
 
-        CONSISTENCY_CHECK_MSGF((vmDomainFileDeleted != vmDomainFile),
-            ("A Module Unload event was sent for a module, but it still shows up in the enumeration.\n vmDomainFileDeleted=%p\n",
-            VmPtrToCookie(vmDomainFileDeleted)));
+        CONSISTENCY_CHECK_MSGF((vmDomainAssemblyDeleted != vmDomainAssembly),
+            ("A Module Unload event was sent for a module, but it still shows up in the enumeration.\n vmDomainAssemblyDeleted=%p\n",
+            VmPtrToCookie(vmDomainAssemblyDeleted)));
     }
 }
 
@@ -1499,7 +1499,7 @@ HRESULT CordbModule::EnableClassLoadCallbacks(BOOL bClassLoadCallbacks)
     if (m_fDynamic && !bClassLoadCallbacks)
         return E_INVALIDARG;
 
-    if (m_vmDomainFile.IsNull())
+    if (m_vmDomainAssembly.IsNull())
         return E_UNEXPECTED;
 
     // Send a Set Class Load Flag event to the left side. There is no need to wait for a response, and this can be
@@ -1511,7 +1511,7 @@ HRESULT CordbModule::EnableClassLoadCallbacks(BOOL bClassLoadCallbacks)
                            DB_IPCE_SET_CLASS_LOAD_FLAG,
                            false,
                            (GetAppDomain()->GetADToken()));
-    event.SetClassLoad.vmDomainFile = this->m_vmDomainFile;
+    event.SetClassLoad.vmDomainAssembly = this->m_vmDomainAssembly;
     event.SetClassLoad.flag = (bClassLoadCallbacks == TRUE);
 
     HRESULT hr = pProcess->m_cordb->SendIPCEvent(pProcess, &event,
@@ -2041,7 +2041,7 @@ HRESULT CordbModule::ResolveTypeRef(mdTypeRef token, CordbClass **ppClass)
         return E_INVALIDARG;
     }
 
-    if (m_vmDomainFile.IsNull() || m_pAppDomain == NULL)
+    if (m_vmDomainAssembly.IsNull() || m_pAppDomain == NULL)
     {
         return E_UNEXPECTED;
     }
@@ -2050,7 +2050,7 @@ HRESULT CordbModule::ResolveTypeRef(mdTypeRef token, CordbClass **ppClass)
     *ppClass = NULL;
     EX_TRY
     {
-        TypeRefData inData = {m_vmDomainFile, token};
+        TypeRefData inData = {m_vmDomainAssembly, token};
         TypeRefData outData;
 
         {
@@ -2058,7 +2058,7 @@ HRESULT CordbModule::ResolveTypeRef(mdTypeRef token, CordbClass **ppClass)
             pProcess->GetDAC()->ResolveTypeReference(&inData, &outData);
         }
 
-        CordbModule * pModule = m_pAppDomain->LookupOrCreateModule(outData.vmDomainFile);
+        CordbModule * pModule = m_pAppDomain->LookupOrCreateModule(outData.vmDomainAssembly);
         IfFailThrow(pModule->LookupClassByToken(outData.typeToken, ppClass));
     }
     EX_CATCH_HRESULT(hr);
@@ -2271,7 +2271,7 @@ HRESULT CordbModule::ApplyChangesInternal(ULONG  cbMetaData,
     FAIL_IF_NEUTERED(this);
     INTERNAL_SYNC_API_ENTRY(this->GetProcess()); //
 
-    if (m_vmDomainFile.IsNull())
+    if (m_vmDomainAssembly.IsNull())
         return E_UNEXPECTED;
 
 #ifdef FEATURE_ENC_SUPPORTED
@@ -2288,7 +2288,7 @@ HRESULT CordbModule::ApplyChangesInternal(ULONG  cbMetaData,
         DebuggerIPCEvent event;
         GetProcess()->InitIPCEvent(&event, DB_IPCE_APPLY_CHANGES, false, VMPTR_AppDomain::NullPtr());
 
-        event.ApplyChanges.vmDomainFile = this->m_vmDomainFile;
+        event.ApplyChanges.vmDomainAssembly = this->m_vmDomainAssembly;
 
         // Have the left-side create a buffer for us to store the delta into
         ULONG cbSize = cbMetaData+cbIL;
@@ -2354,7 +2354,7 @@ HRESULT CordbModule::ApplyChangesInternal(ULONG  cbMetaData,
                 CordbModule* pModule = NULL;
 
 
-                pModule = pAppDomain->LookupOrCreateModule(retEvent->EnCUpdate.vmDomainFile); // throws
+                pModule = pAppDomain->LookupOrCreateModule(retEvent->EnCUpdate.vmDomainAssembly); // throws
                 _ASSERTE(pModule != NULL);
 
                 // update to the newest version
@@ -2412,7 +2412,7 @@ HRESULT CordbModule::SetJMCStatus(
     FAIL_IF_NEUTERED(this);
     ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess());
 
-    if (m_vmDomainFile.IsNull())
+    if (m_vmDomainAssembly.IsNull())
         return E_UNEXPECTED;
 
     // @todo -allow the other parameters. These are functions that have default status
@@ -2431,7 +2431,7 @@ HRESULT CordbModule::SetJMCStatus(
     // Tell the LS that this module is/is not user code
     DebuggerIPCEvent event;
     pProcess->InitIPCEvent(&event, DB_IPCE_SET_MODULE_JMC_STATUS, true, this->GetAppDomain()->GetADToken());
-    event.SetJMCFunctionStatus.vmDomainFile = m_vmDomainFile;
+    event.SetJMCFunctionStatus.vmDomainAssembly = m_vmDomainAssembly;
     event.SetJMCFunctionStatus.dwStatus = fIsUserCode;
 
 
@@ -2520,10 +2520,10 @@ CordbAssembly * CordbModule::ResolveAssemblyInternal(mdToken tkAssemblyRef)
 
     CordbAssembly *    pAssembly = NULL;
 
-    if (!m_vmDomainFile.IsNull())
+    if (!m_vmDomainAssembly.IsNull())
     {
         // Get DAC to do the real work to resolve the assembly
-        VMPTR_DomainAssembly vmDomainAssembly = GetProcess()->GetDAC()->ResolveAssembly(m_vmDomainFile, tkAssemblyRef);
+        VMPTR_DomainAssembly vmDomainAssembly = GetProcess()->GetDAC()->ResolveAssembly(m_vmDomainAssembly, tkAssemblyRef);
 
         // now find the ICorDebugAssembly corresponding to it
         if (!vmDomainAssembly.IsNull() && m_pAppDomain != NULL)
@@ -2694,7 +2694,7 @@ HRESULT CordbModule::SetJITCompilerFlags(DWORD dwFlags)
             if (SUCCEEDED(hr))
             {
                 // DD interface will check if it's a valid time to change the flags.
-                hr = pProcess->GetDAC()->SetCompilerFlags(GetRuntimeDomainFile(), fAllowJitOpts, fEnableEnC);
+                hr = pProcess->GetDAC()->SetCompilerFlags(GetRuntimeDomainAssembly(), fAllowJitOpts, fEnableEnC);
             }
         }
     }
@@ -2730,7 +2730,7 @@ HRESULT CordbModule::GetJITCompilerFlags(DWORD *pdwFlags )
         BOOL fEnableEnC;
 
         pProcess->GetDAC()->GetCompilerFlags (
-            GetRuntimeDomainFile(),
+            GetRuntimeDomainAssembly(),
             &fAllowJitOpts,
             &fEnableEnC);
 
diff --git a/src/coreclr/debug/di/process.cpp b/src/coreclr/debug/di/process.cpp
index 26f1747d87a2c8..1abed121f3e5ad 100644
--- a/src/coreclr/debug/di/process.cpp
+++ b/src/coreclr/debug/di/process.cpp
@@ -2562,10 +2562,10 @@ HRESULT CordbProcess::GetTypeForObject(CORDB_ADDRESS addr, CordbAppDomain* pAppD
 {
     VMPTR_AppDomain appDomain;
     VMPTR_Module mod;
-    VMPTR_DomainFile domainFile;
+    VMPTR_DomainAssembly domainAssembly;
 
     HRESULT hr = E_FAIL;
-    if (GetDAC()->GetAppDomainForObject(addr, &appDomain, &mod, &domainFile))
+    if (GetDAC()->GetAppDomainForObject(addr, &appDomain, &mod, &domainAssembly))
     {
         if (pAppDomainOverride)
         {
@@ -4429,15 +4429,15 @@ class ShimModuleCallbackData
     // Callback invoked from DAC enumeration.
     //
     // arguments:
-    //    vmDomainFile - VMPTR for Module
+    //    vmDomainAssembly - VMPTR for Module
     //    pData - a 'this' pointer
     //
-    static void Callback(VMPTR_DomainFile vmDomainFile, void * pData)
+    static void Callback(VMPTR_DomainAssembly vmDomainAssembly, void * pData)
     {
         ShimModuleCallbackData * pThis = static_cast<ShimModuleCallbackData *> (pData);
         INTERNAL_DAC_CALLBACK(pThis->m_pProcess);
 
-        CordbModule * pModule = pThis->m_pAssembly->GetAppDomain()->LookupOrCreateModule(vmDomainFile);
+        CordbModule * pModule = pThis->m_pAssembly->GetAppDomain()->LookupOrCreateModule(vmDomainAssembly);
 
         pThis->SetAndMoveNext(pModule);
     }
@@ -5063,7 +5063,7 @@ void CordbProcess::RawDispatchEvent(
 
     case DB_IPCE_METADATA_UPDATE:
         {
-            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->MetadataUpdateData.vmDomainFile);
+            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->MetadataUpdateData.vmDomainAssembly);
             pModule->RefreshMetaData();
         }
         break;
@@ -5071,7 +5071,7 @@ void CordbProcess::RawDispatchEvent(
     case DB_IPCE_LOAD_MODULE:
         {
             _ASSERTE (pAppDomain != NULL);
-            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->LoadModuleData.vmDomainFile);
+            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->LoadModuleData.vmDomainAssembly);
 
             {
                 pModule->SetLoadEventContinueMarker();
@@ -5123,12 +5123,12 @@ void CordbProcess::RawDispatchEvent(
         {
             STRESS_LOG3(LF_CORDB, LL_INFO100, "RCET::HRCE: unload module on thread %#x Mod:0x%x AD:0x%08x\n",
                  dwVolatileThreadId,
-                 VmPtrToCookie(pEvent->UnloadModuleData.vmDomainFile),
+                 VmPtrToCookie(pEvent->UnloadModuleData.vmDomainAssembly),
                  VmPtrToCookie(pEvent->vmAppDomain));
 
             PREFIX_ASSUME (pAppDomain != NULL);
 
-            CordbModule *module = pAppDomain->LookupOrCreateModule(pEvent->UnloadModuleData.vmDomainFile);
+            CordbModule *module = pAppDomain->LookupOrCreateModule(pEvent->UnloadModuleData.vmDomainAssembly);
 
             if (module == NULL)
             {
@@ -5149,7 +5149,7 @@ void CordbProcess::RawDispatchEvent(
                 pCallback1->UnloadModule(pAppDomain, module);
             }
 
-            pAppDomain->m_modules.RemoveBase(VmPtrToCookie(pEvent->UnloadModuleData.vmDomainFile));
+            pAppDomain->m_modules.RemoveBase(VmPtrToCookie(pEvent->UnloadModuleData.vmDomainAssembly));
         }
         break;
 
@@ -5161,13 +5161,13 @@ void CordbProcess::RawDispatchEvent(
                  "RCET::HRCE: load class on thread %#x Tok:0x%08x Mod:0x%08x Asm:0x%08x AD:0x%08x\n",
                  dwVolatileThreadId,
                  pEvent->LoadClass.classMetadataToken,
-                 VmPtrToCookie(pEvent->LoadClass.vmDomainFile),
+                 VmPtrToCookie(pEvent->LoadClass.vmDomainAssembly),
                  LsPtrToCookie(pEvent->LoadClass.classDebuggerAssemblyToken),
                  VmPtrToCookie(pEvent->vmAppDomain)));
 
             _ASSERTE (pAppDomain != NULL);
 
-            CordbModule* pModule = pAppDomain->LookupOrCreateModule(pEvent->LoadClass.vmDomainFile);
+            CordbModule* pModule = pAppDomain->LookupOrCreateModule(pEvent->LoadClass.vmDomainAssembly);
             if (pModule == NULL)
             {
                 LOG((LF_CORDB, LL_INFO100, "Load Class on not-loaded Module - continue()ing!" ));
@@ -5219,13 +5219,13 @@ void CordbProcess::RawDispatchEvent(
                  "RCET::HRCE: unload class on thread %#x Tok:0x%08x Mod:0x%08x AD:0x%08x\n",
                  dwVolatileThreadId,
                  pEvent->UnloadClass.classMetadataToken,
-                 VmPtrToCookie(pEvent->UnloadClass.vmDomainFile),
+                 VmPtrToCookie(pEvent->UnloadClass.vmDomainAssembly),
                  VmPtrToCookie(pEvent->vmAppDomain)));
 
             // get the appdomain object
             _ASSERTE (pAppDomain != NULL);
 
-            CordbModule *pModule = pAppDomain->LookupOrCreateModule(pEvent->UnloadClass.vmDomainFile);
+            CordbModule *pModule = pAppDomain->LookupOrCreateModule(pEvent->UnloadClass.vmDomainAssembly);
             if (pModule == NULL)
             {
                 LOG((LF_CORDB, LL_INFO100, "Unload Class on not-loaded Module - continue()ing!" ));
@@ -5302,7 +5302,7 @@ void CordbProcess::RawDispatchEvent(
             // determine first whether custom notifications for this type are enabled -- if not
             // we just return without doing anything.
             CordbClass * pNotificationClass = LookupClass(pAppDomain,
-                                                          pEvent->CustomNotification.vmDomainFile,
+                                                          pEvent->CustomNotification.vmDomainAssembly,
                                                           pEvent->CustomNotification.classToken);
 
             // if the class is NULL, that means the debugger never enabled notifications for it. Otherwise,
@@ -5578,7 +5578,7 @@ void CordbProcess::RawDispatchEvent(
             _ASSERTE (pAppDomain != NULL);
 
             // Find the Right Side module for this module.
-            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->UpdateModuleSymsData.vmDomainFile);
+            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->UpdateModuleSymsData.vmDomainAssembly);
             _ASSERTE(pModule != NULL);
 
             // This is a legacy event notification for updated PDBs.
@@ -5652,7 +5652,7 @@ void CordbProcess::RawDispatchEvent(
 
             _ASSERTE(NULL != pAppDomain);
 
-            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->EnCRemap.vmDomainFile);
+            CordbModule * pModule = pAppDomain->LookupOrCreateModule(pEvent->EnCRemap.vmDomainAssembly);
             PREFIX_ASSUME(pModule != NULL);
 
             CordbFunction * pCurFunction    = NULL;
@@ -5708,7 +5708,7 @@ void CordbProcess::RawDispatchEvent(
 
             _ASSERTE(NULL != pAppDomain);
 
-            CordbModule* pModule = pAppDomain->LookupOrCreateModule(pEvent->EnCRemap.vmDomainFile);
+            CordbModule* pModule = pAppDomain->LookupOrCreateModule(pEvent->EnCRemap.vmDomainAssembly);
             PREFIX_ASSUME(pModule != NULL);
 
             // Find the function we're remapping to, which must be the latest version
@@ -14927,16 +14927,16 @@ void CordbProcess::UpdateThreadsForAdUnload(CordbAppDomain * pAppDomain)
 // CordbProcess::LookupClass
 // Looks up a previously constructed CordbClass instance without creating. May return NULL if the
 // CordbClass instance doesn't exist.
-// Argument: (in) vmDomainFile - pointer to the domainfile for the module
+// Argument: (in) vmDomainAssembly - pointer to the domain assembly for the module
 //           (in) mdTypeDef    - metadata token for the class
 // Return value: pointer to a previously created CordbClass instance or NULL in none exists
-CordbClass * CordbProcess::LookupClass(ICorDebugAppDomain * pAppDomain, VMPTR_DomainFile vmDomainFile, mdTypeDef classToken)
+CordbClass * CordbProcess::LookupClass(ICorDebugAppDomain * pAppDomain, VMPTR_DomainAssembly vmDomainAssembly, mdTypeDef classToken)
 {
     _ASSERTE(ThreadHoldsProcessLock());
 
     if (pAppDomain != NULL)
     {
-        CordbModule * pModule = ((CordbAppDomain *)pAppDomain)->m_modules.GetBase(VmPtrToCookie(vmDomainFile));
+        CordbModule * pModule = ((CordbAppDomain *)pAppDomain)->m_modules.GetBase(VmPtrToCookie(vmDomainAssembly));
         if (pModule != NULL)
         {
             return pModule->LookupClass(classToken);
@@ -14949,7 +14949,7 @@ CordbClass * CordbProcess::LookupClass(ICorDebugAppDomain * pAppDomain, VMPTR_Do
 // Look for a specific module in the process.
 //
 // Arguments:
-//    vmDomainFile - non-null module to lookup
+//    vmDomainAssembly - non-null module to lookup
 //
 // Returns:
 //    a CordbModule object for the given cookie. Object may be from the cache, or created
@@ -14957,23 +14957,23 @@ CordbClass * CordbProcess::LookupClass(ICorDebugAppDomain * pAppDomain, VMPTR_Do
 //    Never returns null.  Throws on error.
 //
 // Notes:
-//    A VMPTR_DomainFile has appdomain affinity, but is ultimately scoped to a process.
-//    So if we get a raw VMPTR_DomainFile (eg, from the stackwalker or from some other
+//    A VMPTR_DomainAssembly has appdomain affinity, but is ultimately scoped to a process.
+//    So if we get a raw VMPTR_DomainAssembly (eg, from the stackwalker or from some other
 //    lookup function), then we need to do a process wide lookup since we don't know which
 //    appdomain it's in. If you know the appdomain, you can use code:CordbAppDomain::LookupOrCreateModule.
 //
-CordbModule * CordbProcess::LookupOrCreateModule(VMPTR_DomainFile vmDomainFile)
+CordbModule * CordbProcess::LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAssembly)
 {
     INTERNAL_API_ENTRY(this);
 
     RSLockHolder lockHolder(GetProcess()->GetProcessLock());
-    _ASSERTE(!vmDomainFile.IsNull());
+    _ASSERTE(!vmDomainAssembly.IsNull());
 
-    DomainFileInfo data;
-    GetDAC()->GetDomainFileData(vmDomainFile, &data); // throws
+    DomainAssemblyInfo data;
+    GetDAC()->GetDomainAssemblyData(vmDomainAssembly, &data); // throws
 
     CordbAppDomain * pAppDomain = LookupOrCreateAppDomain(data.vmAppDomain);
-    return pAppDomain->LookupOrCreateModule(vmDomainFile);
+    return pAppDomain->LookupOrCreateModule(vmDomainAssembly);
 }
 
 //---------------------------------------------------------------------------------------
diff --git a/src/coreclr/debug/di/rsappdomain.cpp b/src/coreclr/debug/di/rsappdomain.cpp
index 081baa95216d5b..e140b8a77f13fb 100644
--- a/src/coreclr/debug/di/rsappdomain.cpp
+++ b/src/coreclr/debug/di/rsappdomain.cpp
@@ -829,7 +829,7 @@ CordbAssembly * CordbAppDomain::LookupOrCreateAssembly(VMPTR_Assembly vmAssembly
 // Lookup or create a module within the appdomain
 //
 // Arguments:
-//    vmDomainFile - non-null module to lookup
+//    vmDomainAssembly - non-null module to lookup
 //
 // Returns:
 //    a CordbModule object for the given cookie. Object may be from the cache, or created
@@ -839,26 +839,26 @@ CordbAssembly * CordbAppDomain::LookupOrCreateAssembly(VMPTR_Assembly vmAssembly
 // Notes:
 //    If you don't know which appdomain the module is in, use code:CordbProcess::LookupOrCreateModule.
 //
-CordbModule* CordbAppDomain::LookupOrCreateModule(VMPTR_Module vmModule, VMPTR_DomainFile vmDomainFile)
+CordbModule* CordbAppDomain::LookupOrCreateModule(VMPTR_Module vmModule, VMPTR_DomainAssembly vmDomainAssembly)
 {
     INTERNAL_API_ENTRY(this);
     CordbModule * pModule;
 
     RSLockHolder lockHolder(GetProcess()->GetProcessLock()); // @dbgtodo  locking: push this up.
 
-    _ASSERTE(!vmDomainFile.IsNull() || !vmModule.IsNull());
+    _ASSERTE(!vmDomainAssembly.IsNull() || !vmModule.IsNull());
 
     // check to see if the module is present in this app domain
-    pModule = m_modules.GetBase(vmDomainFile.IsNull() ? VmPtrToCookie(vmModule) : VmPtrToCookie(vmDomainFile));
+    pModule = m_modules.GetBase(vmDomainAssembly.IsNull() ? VmPtrToCookie(vmModule) : VmPtrToCookie(vmDomainAssembly));
     if (pModule != NULL)
     {
         return pModule;
     }
 
     if (vmModule.IsNull())
-        GetProcess()->GetDAC()->GetModuleForDomainFile(vmDomainFile, &vmModule);
+        GetProcess()->GetDAC()->GetModuleForDomainAssembly(vmDomainAssembly, &vmModule);
 
-    RSInitHolder<CordbModule> pModuleInit(new CordbModule(GetProcess(), vmModule, vmDomainFile));
+    RSInitHolder<CordbModule> pModuleInit(new CordbModule(GetProcess(), vmModule, vmDomainAssembly));
     pModule = pModuleInit.TransferOwnershipToHash(&m_modules);
 
     // The appdomains should match.
@@ -868,12 +868,12 @@ CordbModule* CordbAppDomain::LookupOrCreateModule(VMPTR_Module vmModule, VMPTR_D
 }
 
 
-CordbModule* CordbAppDomain::LookupOrCreateModule(VMPTR_DomainFile vmDomainFile)
+CordbModule* CordbAppDomain::LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAssembly)
 {
     INTERNAL_API_ENTRY(this);
 
-    _ASSERTE(!vmDomainFile.IsNull());
-    return LookupOrCreateModule(VMPTR_Module::NullPtr(), vmDomainFile);
+    _ASSERTE(!vmDomainAssembly.IsNull());
+    return LookupOrCreateModule(VMPTR_Module::NullPtr(), vmDomainAssembly);
 }
 
 
@@ -890,7 +890,7 @@ CordbModule* CordbAppDomain::LookupOrCreateModule(VMPTR_DomainFile vmDomainFile)
 //    invokes this callback.
 
 // static
-void CordbAppDomain::ModuleEnumerationCallback(VMPTR_DomainFile vmModule, void * pUserData)
+void CordbAppDomain::ModuleEnumerationCallback(VMPTR_DomainAssembly vmModule, void * pUserData)
 {
     CONTRACTL
     {
diff --git a/src/coreclr/debug/di/rsclass.cpp b/src/coreclr/debug/di/rsclass.cpp
index 40d886de9935e5..4fe8930712a4ed 100644
--- a/src/coreclr/debug/di/rsclass.cpp
+++ b/src/coreclr/debug/di/rsclass.cpp
@@ -781,11 +781,11 @@ void CordbClass::Init(ClassLoadLevel desiredLoadLevel)
         if(desiredLoadLevel == FullInfo)
         {
             VMPTR_AppDomain vmAppDomain = VMPTR_AppDomain::NullPtr();
-            VMPTR_DomainFile vmDomainFile = m_pModule->GetRuntimeDomainFile();
-            if (!vmDomainFile.IsNull())
+            VMPTR_DomainAssembly vmDomainAssembly = m_pModule->GetRuntimeDomainAssembly();
+            if (!vmDomainAssembly.IsNull())
             {
-                DomainFileInfo info;
-                pDac->GetDomainFileData(vmDomainFile, &info);
+                DomainAssemblyInfo info;
+                pDac->GetDomainAssemblyData(vmDomainAssembly, &info);
                 vmAppDomain = info.vmAppDomain;
             }
             pDac->GetClassInfo(vmAppDomain, vmTypeHandle, &m_classInfo);
@@ -941,7 +941,7 @@ void CordbClass::InitEnCFieldInfo(EnCHangingFieldInfo * pEncField,
                         fieldToken,
                         ELEMENT_TYPE_MAX,
                         classToken,
-                        m_pModule->GetRuntimeDomainFile());
+                        m_pModule->GetRuntimeDomainAssembly());
     }
     else
     {
@@ -966,7 +966,7 @@ void CordbClass::InitEnCFieldInfo(EnCHangingFieldInfo * pEncField,
                                                                     // This is used only for log messages, and could
                                                                     // be removed.
                         classToken,                                 // metadata token for the class
-                        m_pModule->GetRuntimeDomainFile());         // Domain file for the class
+                        m_pModule->GetRuntimeDomainAssembly());         // Domain file for the class
     }
 } // CordbClass::InitFieldData
 
diff --git a/src/coreclr/debug/di/rsfunction.cpp b/src/coreclr/debug/di/rsfunction.cpp
index b901a1ded88fea..f2384411bc0f2a 100644
--- a/src/coreclr/debug/di/rsfunction.cpp
+++ b/src/coreclr/debug/di/rsfunction.cpp
@@ -705,7 +705,7 @@ HRESULT CordbFunction::GetILCodeAndSigToken()
                 // and we also fallback on creating an empty ILCode object.
                 // See issue DD 273199 for cases where IL and NGEN metadata mismatch (different RVAs).
                 ALLOW_DATATARGET_MISSING_OR_INCONSISTENT_MEMORY(
-                    pProcess->GetDAC()->GetILCodeAndSig(m_pModule->GetRuntimeDomainFile(),
+                    pProcess->GetDAC()->GetILCodeAndSig(m_pModule->GetRuntimeDomainAssembly(),
                                                             m_MDToken,
                                                             &codeInfo,
                                                             &localVarSigToken);
@@ -782,7 +782,7 @@ HRESULT CordbFunction::InitParentClassOfFunction()
         }
 
         mdTypeDef classMetadataToken;
-        VMPTR_DomainFile vmDomainFile = m_pModule->GetRuntimeDomainFile();
+        VMPTR_DomainAssembly vmDomainAssembly = m_pModule->GetRuntimeDomainAssembly();
 
         classMetadataToken = InitParentClassOfFunctionHelper(m_MDToken);
 
@@ -795,7 +795,7 @@ HRESULT CordbFunction::InitParentClassOfFunction()
             CordbAssembly *pAssembly = m_pModule->GetCordbAssembly();
             PREFIX_ASSUME(pAssembly != NULL);
 
-            CordbModule* pClassModule = pAssembly->GetAppDomain()->LookupOrCreateModule(vmDomainFile);
+            CordbModule* pClassModule = pAssembly->GetAppDomain()->LookupOrCreateModule(vmDomainAssembly);
             PREFIX_ASSUME(pClassModule != NULL);
 
             CordbClass *pClass;
@@ -850,7 +850,7 @@ HRESULT CordbFunction::InitNativeCodeInfo()
             // All we actually need is the start address and method desc which are cheap to get relative
             // to some of the other members. So far this doesn't appear to be a perf hotspot, but if it
             // shows up in some scenario it wouldn't be too hard to improve it
-            pProcess->GetDAC()->GetNativeCodeInfo(m_pModule->GetRuntimeDomainFile(), m_MDToken, &codeInfo);
+            pProcess->GetDAC()->GetNativeCodeInfo(m_pModule->GetRuntimeDomainAssembly(), m_MDToken, &codeInfo);
         }
 
         // populate the m_nativeCode pointer with the code info we found
@@ -904,7 +904,7 @@ HRESULT CordbFunction::SetJMCStatus(BOOL fIsUserCode)
 
     DebuggerIPCEvent event;
     pProcess->InitIPCEvent(&event, DB_IPCE_SET_METHOD_JMC_STATUS, true, m_pModule->GetAppDomain()->GetADToken());
-    event.SetJMCFunctionStatus.vmDomainFile = m_pModule->GetRuntimeDomainFile();
+    event.SetJMCFunctionStatus.vmDomainAssembly = m_pModule->GetRuntimeDomainAssembly();
     event.SetJMCFunctionStatus.funcMetadataToken   = m_MDToken;
     event.SetJMCFunctionStatus.dwStatus            = fIsUserCode;
 
@@ -956,7 +956,7 @@ HRESULT CordbFunction::GetJMCStatus(BOOL * pfIsUserCode)
     // Ask the left-side if a method is user code or not.
     DebuggerIPCEvent event;
     pProcess->InitIPCEvent(&event, DB_IPCE_GET_METHOD_JMC_STATUS, true, m_pModule->GetAppDomain()->GetADToken());
-    event.SetJMCFunctionStatus.vmDomainFile = m_pModule->GetRuntimeDomainFile();
+    event.SetJMCFunctionStatus.vmDomainAssembly = m_pModule->GetRuntimeDomainAssembly();
     event.SetJMCFunctionStatus.funcMetadataToken   = m_MDToken;
 
 
diff --git a/src/coreclr/debug/di/rspriv.h b/src/coreclr/debug/di/rspriv.h
index bbb9dbd5d5253e..acb8d4c32473cd 100644
--- a/src/coreclr/debug/di/rspriv.h
+++ b/src/coreclr/debug/di/rspriv.h
@@ -2505,13 +2505,13 @@ class CordbAppDomain : public CordbBase,
     CordbModule * GetModuleFromMetaDataInterface(IUnknown *pIMetaData);
 
     // Lookup a module from the cache.  Create and to the cache if needed.
-    CordbModule * LookupOrCreateModule(VMPTR_Module vmModuleToken, VMPTR_DomainFile vmDomainFileToken);
+    CordbModule * LookupOrCreateModule(VMPTR_Module vmModuleToken, VMPTR_DomainAssembly vmDomainAssemblyToken);
 
     // Lookup a module from the cache.  Create and to the cache if needed.
-    CordbModule * LookupOrCreateModule(VMPTR_DomainFile vmDomainFileToken);
+    CordbModule * LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAssemblyToken);
 
     // Callback from DAC for module enumeration
-    static void ModuleEnumerationCallback(VMPTR_DomainFile vmModule, void * pUserData);
+    static void ModuleEnumerationCallback(VMPTR_DomainAssembly vmModule, void * pUserData);
 
     // Use DAC to add any modules for this assembly.
     void PrepopulateModules();
@@ -2543,7 +2543,7 @@ class CordbAppDomain : public CordbBase,
     // Cache of modules in this appdomain. In the VM, modules live in an assembly.
     // This cache lives on the appdomain because we generally want to do appdomain (or process)
     // wide lookup.
-    // This is indexed by VMPTR_DomainFile, which has appdomain affinity.
+    // This is indexed by VMPTR_DomainAssembly, which has appdomain affinity.
     // This is populated by code:CordbAppDomain::LookupOrCreateModule (which may be invoked
     // anytime the RS gets hold of a VMPTR), and are removed at the unload event.
     CordbSafeHashTable<CordbModule>      m_modules;
@@ -3454,9 +3454,9 @@ class CordbProcess :
 
     // Looks up a previously constructed CordbClass instance without creating. May return NULL if the
     // CordbClass instance doesn't exist.
-    CordbClass * LookupClass(ICorDebugAppDomain * pAppDomain, VMPTR_DomainFile vmDomainFile, mdTypeDef classToken);
+    CordbClass * LookupClass(ICorDebugAppDomain * pAppDomain, VMPTR_DomainAssembly vmDomainAssembly, mdTypeDef classToken);
 
-    CordbModule * LookupOrCreateModule(VMPTR_DomainFile vmDomainFile);
+    CordbModule * LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAssembly);
 
 #ifdef FEATURE_INTEROP_DEBUGGING
     CordbUnmanagedThread *GetUnmanagedThread(DWORD dwThreadId)
@@ -4141,7 +4141,7 @@ class CordbModule : public CordbBase,
 public:
     CordbModule(CordbProcess *      process,
                 VMPTR_Module        vmModule,
-                VMPTR_DomainFile    vmDomainFile);
+                VMPTR_DomainAssembly    vmDomainAssembly);
 
     virtual ~CordbModule();
     virtual void Neuter();
@@ -4348,9 +4348,9 @@ class CordbModule : public CordbBase,
 
     const WCHAR * GetNGenImagePath();
 
-    const VMPTR_DomainFile GetRuntimeDomainFile ()
+    const VMPTR_DomainAssembly GetRuntimeDomainAssembly ()
     {
-        return m_vmDomainFile;
+        return m_vmDomainAssembly;
     }
 
     const VMPTR_Module GetRuntimeModule()
@@ -4385,7 +4385,7 @@ class CordbModule : public CordbBase,
 
     // The real handle into the VM for a module. This is appdomain aware.
     // This is the primary VM counterpart for the CordbModule.
-    VMPTR_DomainFile m_vmDomainFile;
+    VMPTR_DomainAssembly m_vmDomainAssembly;
 
     VMPTR_Module m_vmModule;
 
@@ -4800,7 +4800,7 @@ class CordbType : public CordbBase, public ICorDebugType, public ICorDebugType2
     void DestNaryType(Instantiation *pInst);
 
     CorElementType GetElementType() { return m_elementType; }
-    VMPTR_DomainFile GetDomainFile();
+    VMPTR_DomainAssembly GetDomainAssembly();
     VMPTR_Module GetModule();
 
     // If this is a ptr type, get the CordbType that it points to.
diff --git a/src/coreclr/debug/di/rsstackwalk.cpp b/src/coreclr/debug/di/rsstackwalk.cpp
index 42732435db409e..b115349593fc25 100644
--- a/src/coreclr/debug/di/rsstackwalk.cpp
+++ b/src/coreclr/debug/di/rsstackwalk.cpp
@@ -634,7 +634,7 @@ HRESULT CordbStackWalk::GetFrameWorker(ICorDebugFrame ** ppFrame)
         _ASSERTE(pCurrentAppDomain != NULL);
 
         // Lookup the module
-        CordbModule* pModule = pCurrentAppDomain->LookupOrCreateModule(pFuncData->vmDomainFile);
+        CordbModule* pModule = pCurrentAppDomain->LookupOrCreateModule(pFuncData->vmDomainAssembly);
         PREFIX_ASSUME(pModule != NULL);
 
         // Create or look up a CordbNativeCode.  There is one for each jitted instance of a method,
diff --git a/src/coreclr/debug/di/rsthread.cpp b/src/coreclr/debug/di/rsthread.cpp
index 75479f9540ecf6..38a498752771a6 100644
--- a/src/coreclr/debug/di/rsthread.cpp
+++ b/src/coreclr/debug/di/rsthread.cpp
@@ -1629,8 +1629,8 @@ HRESULT CordbThread::SetIP(bool fCanSetIPOnly,
 
     ATT_REQUIRE_STOPPED_MAY_FAIL(GetProcess());
 
-    VMPTR_DomainFile vmDomainFile = pNativeCode->GetModule()->m_vmDomainFile;
-    _ASSERTE(!vmDomainFile.IsNull());
+    VMPTR_DomainAssembly vmDomainAssembly = pNativeCode->GetModule()->m_vmDomainAssembly;
+    _ASSERTE(!vmDomainAssembly.IsNull());
 
     // If this thread is stopped due to an exception, never allow SetIP
     if (HasException())
@@ -1642,7 +1642,7 @@ HRESULT CordbThread::SetIP(bool fCanSetIPOnly,
     GetProcess()->InitIPCEvent(&event, DB_IPCE_SET_IP, true, GetAppDomain()->GetADToken());
     event.SetIP.fCanSetIPOnly = fCanSetIPOnly;
     event.SetIP.vmThreadToken = m_vmThreadToken;
-    event.SetIP.vmDomainFile = vmDomainFile;
+    event.SetIP.vmDomainAssembly = vmDomainAssembly;
     event.SetIP.mdMethod = pNativeCode->GetMetadataToken();
     event.SetIP.vmMethodDesc = pNativeCode->GetVMNativeCodeMethodDescToken();
     event.SetIP.startAddress = pNativeCode->GetAddress();
@@ -1654,7 +1654,7 @@ HRESULT CordbThread::SetIP(bool fCanSetIPOnly,
         "mod:0x%x  MethodDef:0x%x offset:0x%x  il?:0x%x\n",
          GetCurrentThreadId(),
          VmPtrToCookie(m_vmThreadToken),
-         VmPtrToCookie(vmDomainFile),
+         VmPtrToCookie(vmDomainAssembly),
          pNativeCode->GetMetadataToken(),
          offset,
          fIsIL));
@@ -5249,7 +5249,7 @@ CordbInternalFrame::CordbInternalFrame(CordbThread *          pThread,
         // Find the module of the function.  Note that this module isn't necessarily in the same domain as our frame.
         // FuncEval frames can point to methods they are going to invoke in another domain.
         CordbModule * pModule = NULL;
-        pModule = GetProcess()->LookupOrCreateModule(pData->stubFrame.vmDomainFile);
+        pModule = GetProcess()->LookupOrCreateModule(pData->stubFrame.vmDomainAssembly);
         _ASSERTE(pModule != NULL);
 
         //
@@ -9645,7 +9645,7 @@ HRESULT CordbEval::CallParameterizedFunction(ICorDebugFunction *pFunction,
         event.FuncEval.vmThreadToken = m_thread->m_vmThreadToken;
         event.FuncEval.funcEvalType = m_evalType;
         event.FuncEval.funcMetadataToken = m_function->GetMetadataToken();
-        event.FuncEval.vmDomainFile = m_function->GetModule()->GetRuntimeDomainFile();
+        event.FuncEval.vmDomainAssembly = m_function->GetModule()->GetRuntimeDomainAssembly();
         event.FuncEval.funcEvalKey = hFuncEval.Ptr();
         event.FuncEval.argCount = nArgs;
         event.FuncEval.genericArgsCount = nTypeArgs;
@@ -9828,7 +9828,7 @@ HRESULT CordbEval::NewParameterizedObject(ICorDebugFunction * pConstructor,
     event.FuncEval.vmThreadToken = m_thread->m_vmThreadToken;
     event.FuncEval.funcEvalType = m_evalType;
     event.FuncEval.funcMetadataToken = m_function->GetMetadataToken();
-    event.FuncEval.vmDomainFile = m_function->GetModule()->GetRuntimeDomainFile();
+    event.FuncEval.vmDomainAssembly = m_function->GetModule()->GetRuntimeDomainAssembly();
     event.FuncEval.funcEvalKey = hFuncEval.Ptr();
     event.FuncEval.argCount = nArgs;
     event.FuncEval.genericArgsCount = nTypeArgs;
@@ -9929,7 +9929,7 @@ HRESULT CordbEval::NewParameterizedObjectNoConstructor(ICorDebugClass * pClass,
     event.FuncEval.funcEvalType = m_evalType;
     event.FuncEval.funcMetadataToken = mdMethodDefNil;
     event.FuncEval.funcClassMetadataToken = (mdTypeDef)m_class->m_id;
-    event.FuncEval.vmDomainFile = m_class->GetModule()->GetRuntimeDomainFile();
+    event.FuncEval.vmDomainAssembly = m_class->GetModule()->GetRuntimeDomainAssembly();
     event.FuncEval.funcEvalKey = hFuncEval.Ptr();
     event.FuncEval.argCount = 0;
     event.FuncEval.genericArgsCount = nTypeArgs;
@@ -10024,7 +10024,7 @@ HRESULT CordbEval::NewStringWithLength(LPCWSTR wszString, UINT iLength)
     // Note: no function or module here...
     event.FuncEval.funcMetadataToken = mdMethodDefNil;
     event.FuncEval.funcClassMetadataToken = mdTypeDefNil;
-    event.FuncEval.vmDomainFile = VMPTR_DomainFile::NullPtr();
+    event.FuncEval.vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
     event.FuncEval.argCount = 0;
     event.FuncEval.genericArgsCount = 0;
     event.FuncEval.genericArgsNodeCount = 0;
@@ -10141,7 +10141,7 @@ HRESULT CordbEval::NewParameterizedArray(ICorDebugType * pElementType,
     // Note: no function or module here...
     event.FuncEval.funcMetadataToken = mdMethodDefNil;
     event.FuncEval.funcClassMetadataToken = mdTypeDefNil;
-    event.FuncEval.vmDomainFile = VMPTR_DomainFile::NullPtr();
+    event.FuncEval.vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
     event.FuncEval.argCount = 0;
     event.FuncEval.genericArgsCount = 1;
 
diff --git a/src/coreclr/debug/di/rstype.cpp b/src/coreclr/debug/di/rstype.cpp
index 3d807bb2434f53..af6a8f5e14a58e 100644
--- a/src/coreclr/debug/di/rstype.cpp
+++ b/src/coreclr/debug/di/rstype.cpp
@@ -1191,7 +1191,7 @@ HRESULT CordbType::TypeDataToType(CordbAppDomain *pAppDomain, DebuggerIPCE_Basic
             DebuggerIPCE_ExpandedTypeData e;
             e.elementType = et;
             e.ClassTypeData.metadataToken = data->metadataToken;
-            e.ClassTypeData.vmDomainFile = data->vmDomainFile;
+            e.ClassTypeData.vmDomainAssembly = data->vmDomainAssembly;
             e.ClassTypeData.vmModule = data->vmModule;
             e.ClassTypeData.typeHandle = data->vmTypeHandle;
             return CordbType::TypeDataToType(pAppDomain, &e, pRes);
@@ -1254,7 +1254,7 @@ HRESULT CordbType::TypeDataToType(CordbAppDomain *pAppDomain, DebuggerIPCE_Expan
         CordbModule * pClassModule = NULL;
         EX_TRY
         {
-            pClassModule = pAppDomain->LookupOrCreateModule(data->ClassTypeData.vmModule, data->ClassTypeData.vmDomainFile);
+            pClassModule = pAppDomain->LookupOrCreateModule(data->ClassTypeData.vmModule, data->ClassTypeData.vmDomainAssembly);
         }
         EX_CATCH_HRESULT(hr);
         if( pClassModule == NULL )
@@ -1611,7 +1611,7 @@ HRESULT CordbType::InitStringOrObjectClass(BOOL fForceInit)
         //
         CordbProcess *pProcess = GetProcess();
         mdTypeDef metadataToken;
-        VMPTR_DomainFile vmDomainFile = VMPTR_DomainFile::NullPtr();
+        VMPTR_DomainAssembly vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
         VMPTR_Module vmModule = VMPTR_Module::NullPtr();
 
         {
@@ -1620,13 +1620,13 @@ HRESULT CordbType::InitStringOrObjectClass(BOOL fForceInit)
                                               m_elementType,
                                               &metadataToken,
                                               &vmModule,
-                                              &vmDomainFile);
+                                              &vmDomainAssembly);
         }
 
         //
         // Step 2) Lookup CordbClass based off token + Module.
         //
-        CordbModule * pTypeModule = m_appdomain->LookupOrCreateModule(vmModule, vmDomainFile);
+        CordbModule * pTypeModule = m_appdomain->LookupOrCreateModule(vmModule, vmDomainAssembly);
 
         _ASSERTE(pTypeModule != NULL);
         IfFailThrow(pTypeModule->LookupOrCreateClass(metadataToken, &m_pClass));
@@ -1704,7 +1704,7 @@ HRESULT CordbType::InitInstantiationFieldInfo(BOOL fForceInit)
             // this may be called multiple times. Each call will discard previous values in m_fieldList and reinitialize
             // the list with updated information
             RSLockHolder lockHolder(pProcess->GetProcessLock());
-            pProcess->GetDAC()->GetInstantiationFieldInfo(m_pClass->GetModule()->GetRuntimeDomainFile(),
+            pProcess->GetDAC()->GetInstantiationFieldInfo(m_pClass->GetModule()->GetRuntimeDomainAssembly(),
                                                           m_typeHandleExact,
                                                           typeHandleApprox,
                                                           &m_fieldList,
@@ -1876,23 +1876,23 @@ CordbType::GetUnboxedObjectSize(ULONG32 *pObjectSize)
     }
 }
 
-VMPTR_DomainFile CordbType::GetDomainFile()
+VMPTR_DomainAssembly CordbType::GetDomainAssembly()
 {
     if (m_pClass != NULL)
     {
         CordbModule * pModule = m_pClass->GetModule();
         if (pModule)
         {
-            return pModule->m_vmDomainFile;
+            return pModule->m_vmDomainAssembly;
         }
         else
         {
-            return VMPTR_DomainFile::NullPtr();
+            return VMPTR_DomainAssembly::NullPtr();
         }
     }
     else
     {
-        return VMPTR_DomainFile::NullPtr();
+        return VMPTR_DomainAssembly::NullPtr();
     }
 }
 
@@ -1937,7 +1937,7 @@ HRESULT CordbType::TypeToBasicTypeData(DebuggerIPCE_BasicTypeData *data)
     case ELEMENT_TYPE_PTR:
         data->elementType = m_elementType;
         data->metadataToken = mdTokenNil;
-        data->vmDomainFile = VMPTR_DomainFile::NullPtr();
+        data->vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
         data->vmTypeHandle = m_typeHandleExact;
         if (data->vmTypeHandle.IsNull())
         {
@@ -1950,7 +1950,7 @@ HRESULT CordbType::TypeToBasicTypeData(DebuggerIPCE_BasicTypeData *data)
         _ASSERTE(m_pClass != NULL);
         data->elementType = m_pClass->IsValueClassNoInit() ? ELEMENT_TYPE_VALUETYPE : ELEMENT_TYPE_CLASS;
         data->metadataToken = m_pClass->MDToken();
-	    data->vmDomainFile = GetDomainFile();
+	    data->vmDomainAssembly = GetDomainAssembly();
         data->vmTypeHandle = m_typeHandleExact;
         if (m_pClass->HasTypeParams() && data->vmTypeHandle.IsNull())
         {
@@ -1961,7 +1961,7 @@ HRESULT CordbType::TypeToBasicTypeData(DebuggerIPCE_BasicTypeData *data)
         // This includes all the "primitive" types, in which CorElementType is a sufficient description.
         data->elementType = m_elementType;
         data->metadataToken = mdTokenNil;
-        data->vmDomainFile = VMPTR_DomainFile::NullPtr();
+        data->vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
         data->vmTypeHandle = VMPTR_TypeHandle::NullPtr();
         break;
     }
@@ -2001,7 +2001,7 @@ void CordbType::TypeToExpandedTypeData(DebuggerIPCE_ExpandedTypeData *data)
         {
             data->elementType = m_pClass->IsValueClassNoInit() ? ELEMENT_TYPE_VALUETYPE : ELEMENT_TYPE_CLASS;
             data->ClassTypeData.metadataToken = m_pClass->GetToken();
-            data->ClassTypeData.vmDomainFile = GetDomainFile();
+            data->ClassTypeData.vmDomainAssembly = GetDomainAssembly();
             data->ClassTypeData.vmModule = GetModule();
             data->ClassTypeData.typeHandle = VMPTR_TypeHandle::NullPtr();
 
@@ -2339,14 +2339,14 @@ HRESULT CordbType::GetTypeID(COR_TYPEID *pId)
             {
                 mdTypeDef mdToken;
                 VMPTR_Module vmModule = VMPTR_Module::NullPtr();
-                VMPTR_DomainFile vmDomainFile = VMPTR_DomainFile::NullPtr();
+                VMPTR_DomainAssembly vmDomainAssembly = VMPTR_DomainAssembly::NullPtr();
 
                 // get module and token of the simple type
                 GetProcess()->GetDAC()->GetSimpleType(GetAppDomain()->GetADToken(),
                                                       et,
                                                       &mdToken,
                                                       &vmModule,
-                                                      &vmDomainFile);
+                                                      &vmDomainAssembly);
 
                 vmTypeHandle = GetProcess()->GetDAC()->GetTypeHandle(vmModule, mdToken);
             }
diff --git a/src/coreclr/debug/ee/debugger.cpp b/src/coreclr/debug/ee/debugger.cpp
index 1e326e724250b6..bd96c50fc59d31 100644
--- a/src/coreclr/debug/ee/debugger.cpp
+++ b/src/coreclr/debug/ee/debugger.cpp
@@ -1347,7 +1347,7 @@ DebuggerEval::DebuggerEval(CONTEXT * pContext, DebuggerIPCE_FuncEvalInfo * pEval
     // could get unloaded between now and when the funceval actually starts.  So we stash an
     // AppDomain ID which is safe to use after the AD is unloaded.  It's only safe to
     // use the DebuggerModule* after we've verified the ADID is still valid (i.e. by entering that domain).
-    m_debuggerModule = g_pDebugger->LookupOrCreateModule(pEvalInfo->vmDomainFile);
+    m_debuggerModule = g_pDebugger->LookupOrCreateModule(pEvalInfo->vmDomainAssembly);
     m_funcEvalKey = pEvalInfo->funcEvalKey;
     m_argCount = pEvalInfo->argCount;
     m_targetCodeAddr = NULL;
@@ -5187,10 +5187,10 @@ void Debugger::SendSyncCompleteIPCEvent(bool isEESuspendedForGC)
 }
 
 //
-// Lookup or create a DebuggerModule for the given pDomainFile.
+// Lookup or create a DebuggerModule for the given pDomainAssembly.
 //
 // Arguments:
-//    pDomainFile - non-null domain file.
+//    pDomainAssembly - non-null domain file.
 //
 // Returns:
 //   DebuggerModule instance for the given domain file. May be lazily created.
@@ -5199,36 +5199,36 @@ void Debugger::SendSyncCompleteIPCEvent(bool isEESuspendedForGC)
 //  @dbgtodo JMC - this should go away when we get rid of DebuggerModule.
 //
 
-DebuggerModule * Debugger::LookupOrCreateModule(DomainFile * pDomainFile)
+DebuggerModule * Debugger::LookupOrCreateModule(DomainAssembly * pDomainAssembly)
 {
-    _ASSERTE(pDomainFile != NULL);
-    LOG((LF_CORDB, LL_INFO1000, "D::LOCM df=0x%x\n", pDomainFile));
-    DebuggerModule * pDModule = LookupOrCreateModule(pDomainFile->GetModule(), pDomainFile->GetAppDomain());
-    LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=0x%x ad=0x%x -> dm=0x%x\n", pDomainFile->GetModule(), pDomainFile->GetAppDomain(), pDModule));
+    _ASSERTE(pDomainAssembly != NULL);
+    LOG((LF_CORDB, LL_INFO1000, "D::LOCM df=0x%x\n", pDomainAssembly));
+    DebuggerModule * pDModule = LookupOrCreateModule(pDomainAssembly->GetModule(), pDomainAssembly->GetAppDomain());
+    LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=0x%x ad=0x%x -> dm=0x%x\n", pDomainAssembly->GetModule(), pDomainAssembly->GetAppDomain(), pDModule));
     _ASSERTE(pDModule != NULL);
-    _ASSERTE(pDModule->GetDomainFile() == pDomainFile);
+    _ASSERTE(pDModule->GetDomainAssembly() == pDomainAssembly);
 
     return pDModule;
 }
 
-// Overloaded Wrapper around for VMPTR_DomainFile-->DomainFile*
+// Overloaded Wrapper around for VMPTR_DomainAssembly-->DomainAssembly*
 //
 // Arguments:
-//    vmDomainFile - VMPTR cookie for a domain file. This can be NullPtr().
+//    vmDomainAssembly - VMPTR cookie for a domain file. This can be NullPtr().
 //
 // Returns:
 //    Debugger Module instance for the given domain file. May be lazily created.
 //
 // Notes:
 //    VMPTR comes from IPC events
-DebuggerModule * Debugger::LookupOrCreateModule(VMPTR_DomainFile vmDomainFile)
+DebuggerModule * Debugger::LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAssembly)
 {
-    DomainFile * pDomainFile = vmDomainFile.GetRawPtr();
-    if (pDomainFile == NULL)
+    DomainAssembly * pDomainAssembly = vmDomainAssembly.GetRawPtr();
+    if (pDomainAssembly == NULL)
     {
         return NULL;
     }
-    return LookupOrCreateModule(pDomainFile);
+    return LookupOrCreateModule(pDomainAssembly);
 }
 
 // Lookup or create a DebuggerModule for the given (Module, AppDomain) pair.
@@ -5281,9 +5281,9 @@ DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule, AppDomain *pAppD
         HRESULT hr = S_OK;
         EX_TRY
         {
-            DomainFile * pDomainFile = pModule->GetDomainFile();
-            SIMPLIFYING_ASSUMPTION(pDomainFile != NULL);
-            dmod = AddDebuggerModule(pDomainFile); // throws
+            DomainAssembly * pDomainAssembly = pModule->GetDomainAssembly();
+            SIMPLIFYING_ASSUMPTION(pDomainAssembly != NULL);
+            dmod = AddDebuggerModule(pDomainAssembly); // throws
         }
         EX_CATCH_HRESULT(hr);
         SIMPLIFYING_ASSUMPTION(dmod != NULL); // may not be true in OOM cases; but LS doesn't handle OOM.
@@ -5293,19 +5293,19 @@ DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule, AppDomain *pAppD
     _ASSERTE( (dmod == NULL) || (dmod->GetAppDomain() == pAppDomain) );
 
     LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=0x%x ad=0x%x -> dm=0x%x(Mod=0x%x, DomFile=0x%x, AD=0x%x)\n",
-        pModule, pAppDomain, dmod, dmod->GetRuntimeModule(), dmod->GetDomainFile(), dmod->GetAppDomain()));
+        pModule, pAppDomain, dmod, dmod->GetRuntimeModule(), dmod->GetDomainAssembly(), dmod->GetAppDomain()));
     return dmod;
 }
 
 // Create a new DebuggerModule object
 //
 // Arguments:
-//    pDomainFile-  runtime domain file to create debugger module object around
+//    pDomainAssembly-  runtime domain file to create debugger module object around
 //
 // Returns:
 //    New instnace of a DebuggerModule. Throws on failure.
 //
-DebuggerModule* Debugger::AddDebuggerModule(DomainFile * pDomainFile)
+DebuggerModule* Debugger::AddDebuggerModule(DomainAssembly * pDomainAssembly)
 {
     CONTRACTL
     {
@@ -5314,16 +5314,16 @@ DebuggerModule* Debugger::AddDebuggerModule(DomainFile * pDomainFile)
     }
     CONTRACTL_END;
 
-    LOG((LF_CORDB, LL_INFO1000, "D::ADM df=0x%x\n", pDomainFile));
+    LOG((LF_CORDB, LL_INFO1000, "D::ADM df=0x%x\n", pDomainAssembly));
     DebuggerDataLockHolder chInfo(this);
 
-    Module *     pRuntimeModule = pDomainFile->GetCurrentModule();
-    AppDomain *  pAppDomain     = pDomainFile->GetAppDomain();
+    Module *     pRuntimeModule = pDomainAssembly->GetModule();
+    AppDomain *  pAppDomain     = pDomainAssembly->GetAppDomain();
 
     HRESULT hr = CheckInitModuleTable();
     IfFailThrow(hr);
 
-    DebuggerModule* pModule = new (interopsafe) DebuggerModule(pRuntimeModule, pDomainFile, pAppDomain);
+    DebuggerModule* pModule = new (interopsafe) DebuggerModule(pRuntimeModule, pDomainAssembly, pAppDomain);
     _ASSERTE(pModule != NULL); // throws on oom
 
     TRACE_ALLOC(pModule);
@@ -5332,7 +5332,7 @@ DebuggerModule* Debugger::AddDebuggerModule(DomainFile * pDomainFile)
     // @dbgtodo  inspection/exceptions - this may leak module in OOM case. LS is not OOM resilient; and we
     // expect to get rid of DebuggerModule anyways.
 
-    LOG((LF_CORDB, LL_INFO1000, "D::ADM df=0x%x -> dm=0x%x\n", pDomainFile, pModule));
+    LOG((LF_CORDB, LL_INFO1000, "D::ADM df=0x%x -> dm=0x%x\n", pDomainAssembly, pModule));
     return pModule;
 }
 
@@ -6246,7 +6246,7 @@ void Debugger::LockAndSendEnCRemapEvent(DebuggerJitInfo * dji, SIZE_T currentIP,
     Module *pRuntimeModule = pFD->GetModule();
 
     DebuggerModule * pDModule = LookupOrCreateModule(pRuntimeModule, thread->GetDomain());
-    ipce->EnCRemap.vmDomainFile.SetRawPtr((pDModule ? pDModule->GetDomainFile() : NULL));
+    ipce->EnCRemap.vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL));
 
     LOG((LF_CORDB, LL_INFO10000, "D::LASEnCRE: %s::%s "
         "dmod:0x%x, methodDef:0x%x \n",
@@ -6315,7 +6315,7 @@ void Debugger::LockAndSendEnCRemapCompleteEvent(MethodDesc *pFD)
     Module *pRuntimeModule = pFD->GetModule();
 
     DebuggerModule * pDModule = LookupOrCreateModule(pRuntimeModule, thread->GetDomain());
-    ipce->EnCRemapComplete.vmDomainFile.SetRawPtr((pDModule ? pDModule->GetDomainFile() : NULL));
+    ipce->EnCRemapComplete.vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL));
 
 
     LOG((LF_CORDB, LL_INFO10000, "D::LASEnCRC: %s::%s "
@@ -6381,7 +6381,7 @@ void Debugger::SendEnCUpdateEvent(DebuggerIPCEventType eventType,
     _ASSERTE(pModule->GetDomain()->IsAppDomain());
 
     DebuggerModule * pDModule = LookupOrCreateModule(pModule, pModule->GetDomain()->AsAppDomain());
-    event->EnCUpdate.vmDomainFile.SetRawPtr((pDModule ? pDModule->GetDomainFile() : NULL));
+    event->EnCUpdate.vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL));
 
     m_pRCThread->SendIPCEvent();
 
@@ -9426,7 +9426,7 @@ void Debugger::LoadModule(Module* pRuntimeModule,
                           DWORD dwModuleName, // length of pszModuleName in chars, not including null.
                           Assembly *pAssembly,
                           AppDomain *pAppDomain,
-                          DomainFile *  pDomainFile,
+                          DomainAssembly *  pDomainAssembly,
                           BOOL fAttaching)
 {
 
@@ -9461,13 +9461,13 @@ void Debugger::LoadModule(Module* pRuntimeModule,
         {
             // The loader lookups may throw or togggle GC mode, so do them inside a TRY/Catch and
             // outside any debugger locks.
-            Module * pManifestModule = pRuntimeModule->GetAssembly()->GetManifestModule();
+            Module * pManifestModule = pRuntimeModule->GetAssembly()->GetModule();
 
             _ASSERTE(pManifestModule != pRuntimeModule);
             _ASSERTE(pManifestModule->IsManifest());
             _ASSERTE(pManifestModule->GetAssembly() == pRuntimeModule->GetAssembly());
 
-            DomainFile * pManifestDomainFile = pManifestModule->GetDomainFile();
+            DomainAssembly * pManifestDomainAssembly = pManifestModule->GetDomainAssembly();
 
             DebuggerLockHolder dbgLockHolder(this);
 
@@ -9477,7 +9477,7 @@ void Debugger::LoadModule(Module* pRuntimeModule,
             DebuggerIPCEvent eventMetadataUpdate;
             InitIPCEvent(&eventMetadataUpdate, DB_IPCE_METADATA_UPDATE, NULL, pAppDomain);
 
-            eventMetadataUpdate.MetadataUpdateData.vmDomainFile.SetRawPtr(pManifestDomainFile);
+            eventMetadataUpdate.MetadataUpdateData.vmDomainAssembly.SetRawPtr(pManifestDomainAssembly);
 
             SendRawEvent(&eventMetadataUpdate);
         }
@@ -9499,7 +9499,7 @@ void Debugger::LoadModule(Module* pRuntimeModule,
     // The RS has logic to ignore duplicate ModuleLoad events. We have to send what could possibly be a dup, though,
     // due to some really nasty issues with getting proper assembly and module load events from the loader when dealing
     // with shared assemblies.
-    module = LookupOrCreateModule(pDomainFile);
+    module = LookupOrCreateModule(pDomainAssembly);
     _ASSERTE(module != NULL);
 
 
@@ -9509,18 +9509,18 @@ void Debugger::LoadModule(Module* pRuntimeModule,
     module->SetCanChangeJitFlags(true);
 
 
-    // @dbgtodo  inspection - Check whether the DomainFile we get is consistent with the Module and AppDomain we get.
+    // @dbgtodo  inspection - Check whether the DomainAssembly we get is consistent with the Module and AppDomain we get.
     // We should simply things when we actually get rid of DebuggerModule, possibly by just passing the
-    // DomainFile around.
-    _ASSERTE(module->GetDomainFile()    == pDomainFile);
-    _ASSERTE(module->GetAppDomain()     == pDomainFile->GetAppDomain());
-    _ASSERTE(module->GetRuntimeModule() == pDomainFile->GetModule());
+    // DomainAssembly around.
+    _ASSERTE(module->GetDomainAssembly()    == pDomainAssembly);
+    _ASSERTE(module->GetAppDomain()     == pDomainAssembly->GetAppDomain());
+    _ASSERTE(module->GetRuntimeModule() == pDomainAssembly->GetModule());
 
     // Send a load module event to the Right Side.
     ipce = m_pRCThread->GetIPCEventSendBuffer();
     InitIPCEvent(ipce,DB_IPCE_LOAD_MODULE, pThread, pAppDomain);
 
-    ipce->LoadModuleData.vmDomainFile.SetRawPtr(pDomainFile);
+    ipce->LoadModuleData.vmDomainAssembly.SetRawPtr(pDomainAssembly);
 
     m_pRCThread->SendIPCEvent();
 
@@ -9588,7 +9588,7 @@ void Debugger::SendRawUpdateModuleSymsEvent(Module *pRuntimeModule, AppDomain *p
                  g_pEEInterface->GetThread(),
                  pAppDomain);
 
-    ipce->UpdateModuleSymsData.vmDomainFile.SetRawPtr((module ? module->GetDomainFile() : NULL));
+    ipce->UpdateModuleSymsData.vmDomainAssembly.SetRawPtr((module ? module->GetDomainAssembly() : NULL));
 
     m_pRCThread->SendIPCEvent();
 }
@@ -9695,8 +9695,8 @@ void Debugger::UnloadModule(Module* pRuntimeModule,
 
         STRESS_LOG6(LF_CORDB, LL_INFO10000,
             "D::UM: Unloading RTMod:%#08x (DomFile: %#08x, IsISStream:%#08x); DMod:%#08x(RTMod:%#08x DomFile: %#08x)\n",
-            pRuntimeModule, pRuntimeModule->GetDomainFile(), false,
-            module, module->GetRuntimeModule(), module->GetDomainFile());
+            pRuntimeModule, pRuntimeModule->GetDomainAssembly(), false,
+            module, module->GetRuntimeModule(), module->GetDomainAssembly());
 
         // Note: the appdomain the module was loaded in must match the appdomain we're unloading it from. If it doesn't,
         // then we've either found the wrong DebuggerModule in LookupModule or we were passed bad data.
@@ -9705,7 +9705,7 @@ void Debugger::UnloadModule(Module* pRuntimeModule,
         // Send the unload module event to the Right Side.
         DebuggerIPCEvent* ipce = m_pRCThread->GetIPCEventSendBuffer();
         InitIPCEvent(ipce, DB_IPCE_UNLOAD_MODULE, thread, pAppDomain);
-        ipce->UnloadModuleData.vmDomainFile.SetRawPtr((module ? module->GetDomainFile() : NULL));
+        ipce->UnloadModuleData.vmDomainAssembly.SetRawPtr((module ? module->GetDomainAssembly() : NULL));
         ipce->UnloadModuleData.debuggerAssemblyToken.Set(pRuntimeModule->GetClassLoader()->GetAssembly());
         m_pRCThread->SendIPCEvent();
 
@@ -9877,7 +9877,7 @@ void Debugger::SendClassLoadUnloadEvent (mdTypeDef classMetadataToken,
         InitIPCEvent(pEvent, DB_IPCE_LOAD_CLASS, g_pEEInterface->GetThread(), pAppDomain);
 
         pEvent->LoadClass.classMetadataToken = classMetadataToken;
-        pEvent->LoadClass.vmDomainFile.SetRawPtr((pClassDebuggerModule ? pClassDebuggerModule->GetDomainFile() : NULL));
+        pEvent->LoadClass.vmDomainAssembly.SetRawPtr((pClassDebuggerModule ? pClassDebuggerModule->GetDomainAssembly() : NULL));
         pEvent->LoadClass.classDebuggerAssemblyToken.Set(pAssembly);
 
 
@@ -9889,7 +9889,7 @@ void Debugger::SendClassLoadUnloadEvent (mdTypeDef classMetadataToken,
         InitIPCEvent(pEvent, DB_IPCE_UNLOAD_CLASS, g_pEEInterface->GetThread(), pAppDomain);
 
         pEvent->UnloadClass.classMetadataToken = classMetadataToken;
-        pEvent->UnloadClass.vmDomainFile.SetRawPtr((pClassDebuggerModule ? pClassDebuggerModule->GetDomainFile() : NULL));
+        pEvent->UnloadClass.vmDomainAssembly.SetRawPtr((pClassDebuggerModule ? pClassDebuggerModule->GetDomainAssembly() : NULL));
         pEvent->UnloadClass.classDebuggerAssemblyToken.Set(pAssembly);
     }
 
@@ -9940,10 +9940,10 @@ BOOL Debugger::SendSystemClassLoadUnloadEvent(mdTypeDef classMetadataToken,
 
         // Only notify for app domains where the module has been fully loaded already
         // We used to make a different check here domain->ContainsAssembly() but that
-        // triggers too early in the loading process. FindDomainFile will not become
+        // triggers too early in the loading process. FindDomainAssembly will not become
         // non-NULL until the module is fully loaded into the domain which is what we
         // want.
-        if (classModule->GetDomainFile() != NULL )
+        if (classModule->GetDomainAssembly() != NULL )
         {
             // Find the Left Side module that this class belongs in.
             DebuggerModule* pModule = LookupOrCreateModule(classModule, pAppDomain);
@@ -10528,7 +10528,7 @@ bool Debugger::HandleIPCEvent(DebuggerIPCEvent * pEvent)
             _ASSERTE(hr == S_OK);
             DebuggerBreakpoint * pDebuggerBP = NULL;
 
-            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->BreakpointData.vmDomainFile);
+            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->BreakpointData.vmDomainAssembly);
             Module * pModule = pDebuggerModule->GetRuntimeModule();
             DebuggerMethodInfo * pDMI = GetOrCreateMethodInfo(pModule, pEvent->BreakpointData.funcMetadataToken);
             MethodDesc * pMethodDesc = pEvent->BreakpointData.nativeCodeMethodDescToken.UnWrap();
@@ -10847,7 +10847,7 @@ bool Debugger::HandleIPCEvent(DebuggerIPCEvent * pEvent)
         {
             LOG((LF_ENC, LL_INFO100, "D::HIPCE: DB_IPCE_APPLY_CHANGES 1\n"));
 
-            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->ApplyChanges.vmDomainFile);
+            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->ApplyChanges.vmDomainAssembly);
             //
             // @todo handle error.
             //
@@ -10864,7 +10864,7 @@ bool Debugger::HandleIPCEvent(DebuggerIPCEvent * pEvent)
 
     case DB_IPCE_SET_CLASS_LOAD_FLAG:
         {
-            DebuggerModule *pDebuggerModule = LookupOrCreateModule(pEvent->SetClassLoad.vmDomainFile);
+            DebuggerModule *pDebuggerModule = LookupOrCreateModule(pEvent->SetClassLoad.vmDomainAssembly);
 
             _ASSERTE(pDebuggerModule != NULL);
 
@@ -10914,7 +10914,7 @@ bool Debugger::HandleIPCEvent(DebuggerIPCEvent * pEvent)
                 // unexpected in an OOM situation.  Quickly just sanity check them.
                 //
                 Thread * pThread = pEvent->SetIP.vmThreadToken.GetRawPtr();
-                Module * pModule = pEvent->SetIP.vmDomainFile.GetRawPtr()->GetModule();
+                Module * pModule = pEvent->SetIP.vmDomainAssembly.GetRawPtr()->GetModule();
 
                 // Get the DJI for this function
                 DebuggerMethodInfo * pDMI = GetOrCreateMethodInfo(pModule, pEvent->SetIP.mdMethod);
@@ -11244,7 +11244,7 @@ bool Debugger::HandleIPCEvent(DebuggerIPCEvent * pEvent)
     case DB_IPCE_SET_METHOD_JMC_STATUS:
         {
             // Get the info out of the event
-            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->SetJMCFunctionStatus.vmDomainFile);
+            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->SetJMCFunctionStatus.vmDomainAssembly);
             Module * pModule = pDebuggerModule->GetRuntimeModule();
 
             bool fStatus = (pEvent->SetJMCFunctionStatus.dwStatus != 0);
@@ -11292,7 +11292,7 @@ bool Debugger::HandleIPCEvent(DebuggerIPCEvent * pEvent)
     case DB_IPCE_GET_METHOD_JMC_STATUS:
         {
             // Get the method
-            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->SetJMCFunctionStatus.vmDomainFile);
+            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->SetJMCFunctionStatus.vmDomainAssembly);
 
             Module * pModule = pDebuggerModule->GetRuntimeModule();
 
@@ -11326,7 +11326,7 @@ bool Debugger::HandleIPCEvent(DebuggerIPCEvent * pEvent)
     case DB_IPCE_SET_MODULE_JMC_STATUS:
         {
             // Get data out of event
-            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->SetJMCFunctionStatus.vmDomainFile);
+            DebuggerModule * pDebuggerModule = LookupOrCreateModule(pEvent->SetJMCFunctionStatus.vmDomainAssembly);
 
             bool fStatus = (pEvent->SetJMCFunctionStatus.dwStatus != 0);
 
@@ -11818,7 +11818,7 @@ void Debugger::TypeHandleToBasicTypeInfo(AppDomain *pAppDomain, TypeHandle th, D
     case ELEMENT_TYPE_BYREF:
         res->vmTypeHandle = WrapTypeHandle(th);
         res->metadataToken = mdTokenNil;
-        res->vmDomainFile.SetRawPtr(NULL);
+        res->vmDomainAssembly.SetRawPtr(NULL);
         break;
 
     case ELEMENT_TYPE_CLASS:
@@ -11828,14 +11828,14 @@ void Debugger::TypeHandleToBasicTypeInfo(AppDomain *pAppDomain, TypeHandle th, D
                                                                              // only set if instantiated
             res->metadataToken = th.GetCl();
             DebuggerModule * pDModule = LookupOrCreateModule(th.GetModule(), pAppDomain);
-            res->vmDomainFile.SetRawPtr((pDModule ? pDModule->GetDomainFile() : NULL));
+            res->vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL));
             break;
         }
 
     default:
         res->vmTypeHandle = VMPTR_TypeHandle::NullPtr();
         res->metadataToken = mdTokenNil;
-        res->vmDomainFile.SetRawPtr(NULL);
+        res->vmDomainAssembly.SetRawPtr(NULL);
         break;
     }
     return;
@@ -11907,8 +11907,8 @@ void Debugger::TypeHandleToExpandedTypeInfo(AreValueTypesBoxed boxed,
             res->ClassTypeData.typeHandle = th.HasInstantiation() ? WrapTypeHandle(th) : VMPTR_TypeHandle::NullPtr(); // only set if instantiated
             res->ClassTypeData.metadataToken = th.GetCl();
             DebuggerModule * pModule = LookupOrCreateModule(th.GetModule(), pAppDomain);
-            res->ClassTypeData.vmDomainFile.SetRawPtr((pModule ? pModule->GetDomainFile() : NULL));
-            _ASSERTE(!res->ClassTypeData.vmDomainFile.IsNull());
+            res->ClassTypeData.vmDomainAssembly.SetRawPtr((pModule ? pModule->GetDomainAssembly() : NULL));
+            _ASSERTE(!res->ClassTypeData.vmDomainAssembly.IsNull());
             break;
         }
 
@@ -11968,7 +11968,7 @@ HRESULT Debugger::BasicTypeInfoToTypeHandle(DebuggerIPCE_BasicTypeData *data, Ty
             }
             else
             {
-                DebuggerModule *pDebuggerModule = g_pDebugger->LookupOrCreateModule(data->vmDomainFile);
+                DebuggerModule *pDebuggerModule = g_pDebugger->LookupOrCreateModule(data->vmDomainAssembly);
 
                 th = g_pEEInterface->FindLoadedClass(pDebuggerModule->GetRuntimeModule(), data->metadataToken);
             if (th.IsNull())
@@ -12070,7 +12070,7 @@ TypeHandle Debugger::TypeDataWalk::ReadTypeHandle()
     case ELEMENT_TYPE_CLASS:
     case ELEMENT_TYPE_VALUETYPE:
         {
-            DebuggerModule *pDebuggerModule = g_pDebugger->LookupOrCreateModule(data->data.ClassTypeData.vmDomainFile);
+            DebuggerModule *pDebuggerModule = g_pDebugger->LookupOrCreateModule(data->data.ClassTypeData.vmDomainAssembly);
             th = ReadInstantiation(pDebuggerModule->GetRuntimeModule(), data->data.ClassTypeData.metadataToken, data->numTypeArgs);
             break;
         }
@@ -14403,7 +14403,7 @@ void Debugger::SendLogSwitchSetting(int iLevel,
 //            pDomain    - domain file for the domain in which the notification occurred
 //            classToken - metadata token for the type of the notification object
 void Debugger::SendCustomDebuggerNotification(Thread * pThread,
-                                              DomainFile * pDomain,
+                                              DomainAssembly * pDomain,
                                               mdTypeDef classToken)
 {
     CONTRACTL
@@ -14434,10 +14434,10 @@ void Debugger::SendCustomDebuggerNotification(Thread * pThread,
                      curThread,
                      curThread->GetDomain());
 
-        VMPTR_DomainFile vmDomainFile = VMPTR_DomainFile::MakePtr(pDomain);
+        VMPTR_DomainAssembly vmDomainAssembly = VMPTR_DomainAssembly::MakePtr(pDomain);
 
         ipce->CustomNotification.classToken = classToken;
-        ipce->CustomNotification.vmDomainFile = vmDomainFile;
+        ipce->CustomNotification.vmDomainAssembly = vmDomainAssembly;
 
 
         m_pRCThread->SendIPCEvent();
@@ -14725,16 +14725,6 @@ HRESULT Debugger::IterateAppDomainsForPdbs()
             if (!pDomainAssembly->IsVisibleToDebugger())
                 continue;
 
-            DomainAssembly::ModuleIterator j = pDomainAssembly->IterateModules(kModIterIncludeLoading);
-            while (j.Next())
-            {
-                DomainFile * pDomainFile = j.GetDomainFile();
-                if (!pDomainFile->ShouldNotifyDebugger())
-                    continue;
-
-                Module* pRuntimeModule = pDomainFile->GetModule();
-                CopyModulePdb(pRuntimeModule);
-            }
             if (pDomainAssembly->ShouldNotifyDebugger())
             {
                 CopyModulePdb(pDomainAssembly->GetModule());
diff --git a/src/coreclr/debug/ee/debugger.h b/src/coreclr/debug/ee/debugger.h
index 084f1da6a5c93f..9703354ec4235a 100644
--- a/src/coreclr/debug/ee/debugger.h
+++ b/src/coreclr/debug/ee/debugger.h
@@ -472,7 +472,7 @@ typedef DPTR(class DebuggerModule) PTR_DebuggerModule;
 class DebuggerModule
 {
   public:
-    DebuggerModule(Module * pRuntimeModule, DomainFile * pDomainFile, AppDomain * pAppDomain);
+    DebuggerModule(Module * pRuntimeModule, DomainAssembly * pDomainAssembly, AppDomain * pAppDomain);
 
     // Do we have any optimized code in the module?
     // JMC-probes aren't emitted in optimized code,
@@ -504,16 +504,16 @@ class DebuggerModule
     // If the Runtime module is shared, then this gives a common DM.
     // If the runtime module is not shared, then this is an identity function.
     //
-    // The runtime has the notion of "DomainFile", which is 1:1 with DebuggerModule
+    // The runtime has the notion of "DomainAssembly", which is 1:1 with DebuggerModule
     // and thus 1:1 with CordbModule.  The CordbModule hash table on the RS now uses
-    // the DomainFile as the key instead of DebuggerModule.  This is a temporary
+    // the DomainAssembly as the key instead of DebuggerModule.  This is a temporary
     // workaround to facilitate the removal of DebuggerModule.
     // </TODO>
     DebuggerModule * GetPrimaryModule();
-    DomainFile * GetDomainFile()
+    DomainAssembly * GetDomainAssembly()
     {
         LIMITED_METHOD_DAC_CONTRACT;
-        return m_pRuntimeDomainFile;
+        return m_pRuntimeDomainAssembly;
     }
 
     // Called by DebuggerModuleTable to set our primary module
@@ -528,7 +528,7 @@ class DebuggerModule
     DebuggerModule* m_pPrimaryModule;
 
     PTR_Module     m_pRuntimeModule;
-    PTR_DomainFile m_pRuntimeDomainFile;
+    PTR_DomainAssembly m_pRuntimeDomainAssembly;
 
     AppDomain*     m_pAppDomain;
 
@@ -1893,9 +1893,9 @@ class Debugger : public DebugInterface
                     DWORD dwModuleName,
                     Assembly *pAssembly,
                     AppDomain *pAppDomain,
-                    DomainFile * pDomainFile,
+                    DomainAssembly * pDomainAssembly,
                     BOOL fAttaching);
-    DebuggerModule * AddDebuggerModule(DomainFile * pDomainFile);
+    DebuggerModule * AddDebuggerModule(DomainAssembly * pDomainAssembly);
 
 
     void UnloadModule(Module* pRuntimeModule,
@@ -2068,8 +2068,8 @@ class Debugger : public DebugInterface
 
     bool HandleIPCEvent(DebuggerIPCEvent* event);
 
-    DebuggerModule * LookupOrCreateModule(VMPTR_DomainFile vmDomainFile);
-    DebuggerModule * LookupOrCreateModule(DomainFile * pDomainFile);
+    DebuggerModule * LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAssembly);
+    DebuggerModule * LookupOrCreateModule(DomainAssembly * pDomainAssembly);
     DebuggerModule * LookupOrCreateModule(Module * pModule, AppDomain * pAppDomain);
 
     HRESULT GetAndSendInterceptCommand(DebuggerIPCEvent *event);
@@ -2437,7 +2437,7 @@ class Debugger : public DebugInterface
     }
 
     // send a custom debugger notification to the RS
-    void SendCustomDebuggerNotification(Thread * pThread, DomainFile * pDomain, mdTypeDef classToken);
+    void SendCustomDebuggerNotification(Thread * pThread, DomainAssembly * pDomain, mdTypeDef classToken);
 
     // Send an MDA notification. This ultimately translates to an ICorDebugMDA object on the Right-Side.
     void SendMDANotification(
diff --git a/src/coreclr/debug/ee/debugger.inl b/src/coreclr/debug/ee/debugger.inl
index 0eba7edccf87d5..be4e3f67c4dafa 100644
--- a/src/coreclr/debug/ee/debugger.inl
+++ b/src/coreclr/debug/ee/debugger.inl
@@ -52,16 +52,16 @@ inline DebuggerModuleTable * Debugger::GetModuleTable()
 // @dbgtodo inspection - get rid of this entire class as we move things out-of-proc.
 //-----------------------------------------------------------------------------
 inline DebuggerModule::DebuggerModule(Module *      pRuntimeModule,
-                                      DomainFile *  pDomainFile,
+                                      DomainAssembly *  pDomainAssembly,
                                       AppDomain *   pAppDomain) :
         m_enableClassLoadCallbacks(FALSE),
         m_pPrimaryModule(NULL),
         m_pRuntimeModule(pRuntimeModule),
-        m_pRuntimeDomainFile(pDomainFile),
+        m_pRuntimeDomainAssembly(pDomainAssembly),
         m_pAppDomain(pAppDomain)
 {
     LOG((LF_CORDB,LL_INFO10000, "DM::DM this:0x%x Module:0x%x DF:0x%x AD:0x%x\n",
-        this, pRuntimeModule, pDomainFile, pAppDomain));
+        this, pRuntimeModule, pDomainAssembly, pAppDomain));
 
     // Pick a primary module.
     // Arguably, this could be in DebuggerModuleTable::AddModule
diff --git a/src/coreclr/debug/ee/debuggermodule.cpp b/src/coreclr/debug/ee/debuggermodule.cpp
index fb6fa53652fbee..633567f0dd85f5 100644
--- a/src/coreclr/debug/ee/debuggermodule.cpp
+++ b/src/coreclr/debug/ee/debuggermodule.cpp
@@ -253,7 +253,7 @@ void DebuggerModuleTable::RemoveModule(Module* pModule, AppDomain *pAppDomain)
         if ((pRuntimeModule == pModule) && (pDM->GetAppDomain() == pAppDomain))
         {
             LOG((LF_CORDB, LL_INFO1000, "DMT::RM Removing DebuggerMod:0x%x - Module:0x%x DF:0x%x AD:0x%x\n",
-                pDM, pModule, pDM->GetDomainFile(), pAppDomain));
+                pDM, pModule, pDM->GetDomainAssembly(), pAppDomain));
             TRACE_FREE(pDM);
             DeleteInteropSafe(pDM);
             Delete(HASH(pRuntimeModule), (HASHENTRY *) pDME);
diff --git a/src/coreclr/debug/inc/dacdbiinterface.h b/src/coreclr/debug/inc/dacdbiinterface.h
index 0bda865bd0f59b..82d5c4d1e465aa 100644
--- a/src/coreclr/debug/inc/dacdbiinterface.h
+++ b/src/coreclr/debug/inc/dacdbiinterface.h
@@ -588,27 +588,27 @@ class IDacDbiInterface
     //    pData - required out parameter which will be filled out with module properties
     //
     // Notes:
-    //    See definition of DomainFileInfo for more details about what properties
+    //    See definition of DomainAssemblyInfo for more details about what properties
     //    this gives back.
     virtual
     void GetModuleData(VMPTR_Module vmModule, OUT ModuleInfo * pData) = 0;
 
 
     //
-    // Get properties for a DomainFile
+    // Get properties for a DomainAssembly
     //
     // Arguments:
-    //    vmDomainFile - vm handle to a DomainFile
+    //    vmDomainAssembly - vm handle to a DomainAssembly
     //    pData - required out parameter which will be filled out with module properties
     //
     // Notes:
-    //    See definition of DomainFileInfo for more details about what properties
+    //    See definition of DomainAssemblyInfo for more details about what properties
     //    this gives back.
     virtual
-    void GetDomainFileData(VMPTR_DomainFile vmDomainFile, OUT DomainFileInfo * pData) = 0;
+    void GetDomainAssemblyData(VMPTR_DomainAssembly vmDomainAssembly, OUT DomainAssemblyInfo * pData) = 0;
 
     virtual
-    void GetModuleForDomainFile(VMPTR_DomainFile vmDomainFile, OUT VMPTR_Module * pModule) = 0;
+    void GetModuleForDomainAssembly(VMPTR_DomainAssembly vmDomainAssembly, OUT VMPTR_Module * pModule) = 0;
 
     //.........................................................................
     // These methods were the methods that DBI was calling from IXClrData in V2.
@@ -672,7 +672,7 @@ class IDacDbiInterface
     // Get the values of the JIT Optimization and EnC flags.
     //
     // Arguments:
-    //    vmDomainFile -   (input) VM DomainFile (module) for which we are retrieving flags
+    //    vmDomainAssembly -   (input) VM DomainAssembly (module) for which we are retrieving flags
     //    pfAllowJITOpts - (mandatory output) true iff this is not compiled for debug,
     //                      i.e., without optimization
     //    pfEnableEnc -    (mandatory output) true iff this module has EnC enabled
@@ -687,7 +687,7 @@ class IDacDbiInterface
 
     virtual
     void GetCompilerFlags(
-        VMPTR_DomainFile vmDomainFile,
+        VMPTR_DomainAssembly vmDomainAssembly,
         OUT BOOL * pfAllowJITOpts,
         OUT BOOL * pfEnableEnC) = 0;
 
@@ -695,7 +695,7 @@ class IDacDbiInterface
     // Set the values of the JIT optimization and EnC flags.
     //
     // Arguments:
-    //    vmDomainFile -   (input) VM DomainFile (module) for which we are retrieving flags
+    //    vmDomainAssembly -   (input) VM DomainAssembly (module) for which we are retrieving flags
     //    pfAllowJITOpts - (input) true iff this should not be compiled for debug,
     //                      i.e., without optimization
     //    pfEnableEnc -    (input) true iff this module should have EnC enabled. If this is
@@ -717,7 +717,7 @@ class IDacDbiInterface
     //.........................................................................
 
     virtual
-    HRESULT SetCompilerFlags(VMPTR_DomainFile vmDomainFile,
+    HRESULT SetCompilerFlags(VMPTR_DomainAssembly vmDomainAssembly,
                           BOOL             fAllowJitOpts,
                           BOOL             fEnableEnC) = 0;
 
@@ -784,7 +784,7 @@ class IDacDbiInterface
     // Arguments:
     //    vmModule - new module from the enumeration
     //    pUserData - user data passed to EnumerateModulesInAssembly
-    typedef void (*FP_MODULE_ENUMERATION_CALLBACK)(VMPTR_DomainFile vmModule, CALLBACK_DATA pUserData);
+    typedef void (*FP_MODULE_ENUMERATION_CALLBACK)(VMPTR_DomainAssembly vmModule, CALLBACK_DATA pUserData);
 
     //
     // Enumerates all the code Modules in an assembly.
@@ -1277,7 +1277,7 @@ class IDacDbiInterface
     //    The debugger can't duplicate this policy with 100% accuracy, and
     //    so we need DAC to lookup the assembly that was actually loaded.
     virtual
-    VMPTR_DomainAssembly ResolveAssembly(VMPTR_DomainFile vmScope, mdToken tkAssemblyRef) = 0;
+    VMPTR_DomainAssembly ResolveAssembly(VMPTR_DomainAssembly vmScope, mdToken tkAssemblyRef) = 0;
 
     //-----------------------------------------------------------------------------
     // Interface for initializing the native/IL sequence points and native var info
@@ -1707,13 +1707,13 @@ class IDacDbiInterface
     //
     // Arguments:
     //    Input:
-    //    vmDomainFile   - module containing metadata for the method
+    //    vmDomainAssembly   - module containing metadata for the method
     //    functionToken  - metadata token for the function
     //    Output (required):
     //    codeInfo       - start address and size of the IL
     //    pLocalSigToken - signature token for the method
     virtual
-    void GetILCodeAndSig(VMPTR_DomainFile vmDomainFile,
+    void GetILCodeAndSig(VMPTR_DomainAssembly vmDomainAssembly,
                          mdToken          functionToken,
                          OUT TargetBuffer *   pCodeInfo,
                          OUT mdToken *        pLocalSigToken) = 0;
@@ -1723,7 +1723,7 @@ class IDacDbiInterface
     //    and hot and cold region information.
     // Arguments:
     //    Input:
-    //        vmDomainFile  - module containing metadata for the method
+    //        vmDomainAssembly  - module containing metadata for the method
     //        functionToken - token for the function for which we need code info
     //    Output (required):
     //        pCodeInfo     - data structure describing the native code regions.
@@ -1733,7 +1733,7 @@ class IDacDbiInterface
     //        invalid (i.e., pCodeInfo->IsValid is false).
 
     virtual
-    void GetNativeCodeInfo(VMPTR_DomainFile         vmDomainFile,
+    void GetNativeCodeInfo(VMPTR_DomainAssembly         vmDomainAssembly,
                            mdToken                  functionToken,
                            OUT NativeCodeFunctionData * pCodeInfo) = 0;
 
@@ -1798,7 +1798,7 @@ class IDacDbiInterface
     // get field information and object size for an instantiated generic
     //
     // Arguments:
-    //     input:  vmDomainFile  - module containing metadata for the type
+    //     input:  vmDomainAssembly  - module containing metadata for the type
     //             thExact       - exact type handle for type (may be NULL)
     //             thApprox      - approximate type handle for the type
     //     output:
@@ -1807,7 +1807,7 @@ class IDacDbiInterface
     //             pObjectSize   - size of the instantiated object
     //
     virtual
-    void GetInstantiationFieldInfo (VMPTR_DomainFile             vmDomainFile,
+    void GetInstantiationFieldInfo (VMPTR_DomainAssembly             vmDomainAssembly,
                                     VMPTR_TypeHandle             vmThExact,
                                     VMPTR_TypeHandle             vmThApprox,
                                     OUT DacDbiArrayList<FieldData> * pFieldList,
@@ -1992,12 +1992,12 @@ class IDacDbiInterface
     //     input:  vmAppDomain - Appdomain in which simpleType resides
     //             simpleType  - CorElementType value corresponding to a simple type
     //     output: pMetadataToken - the metadata token corresponding to simpleType,
-    //                              in the scope of vmDomainFile.
-    //             vmDomainFile   - the domainFile for simpleType
+    //                              in the scope of vmDomainAssembly.
+    //             vmDomainAssembly   - the domainAssembly for simpleType
     // Notes:
     //    This is inspection-only. If the type is not yet loaded, it will throw CORDBG_E_CLASS_NOT_LOADED.
     //    It will not try to load a type.
-    //    If the type has been loaded, vmDomainFile will be non-null unless the target is somehow corrupted.
+    //    If the type has been loaded, vmDomainAssembly will be non-null unless the target is somehow corrupted.
     //    In that case, we will throw CORDBG_E_TARGET_INCONSISTENT.
 
     virtual
@@ -2005,7 +2005,7 @@ class IDacDbiInterface
                        CorElementType     simpleType,
                        OUT mdTypeDef *        pMetadataToken,
                        OUT VMPTR_Module     * pVmModule,
-                       OUT VMPTR_DomainFile * pVmDomainFile) = 0;
+                       OUT VMPTR_DomainAssembly * pVmDomainAssembly) = 0;
 
     // for the specified object returns TRUE if the object derives from System.Exception
     virtual
@@ -2459,7 +2459,7 @@ class IDacDbiInterface
     virtual
     bool GetAppDomainForObject(CORDB_ADDRESS obj, OUT VMPTR_AppDomain * pApp,
                                 OUT VMPTR_Module * pModule,
-                                OUT VMPTR_DomainFile * pDomainFile) = 0;
+                                OUT VMPTR_DomainAssembly * pDomainAssembly) = 0;
 
 
     //   Reference Walking.
@@ -2731,7 +2731,7 @@ class IDacDbiInterface
     HRESULT GetDelegateFunctionData(
         DelegateType delegateType,
         VMPTR_Object delegateObject,
-        OUT VMPTR_DomainFile *ppFunctionDomainFile,
+        OUT VMPTR_DomainAssembly *ppFunctionDomainAssembly,
         OUT mdMethodDef *pMethodDef) = 0;
 
     virtual
diff --git a/src/coreclr/debug/inc/dacdbistructures.h b/src/coreclr/debug/inc/dacdbistructures.h
index 5e02a68a792c91..aca5c668de42be 100644
--- a/src/coreclr/debug/inc/dacdbistructures.h
+++ b/src/coreclr/debug/inc/dacdbistructures.h
@@ -162,15 +162,15 @@ struct MSLAYOUT TargetBuffer
 
 //===================================================================================
 // Module properties, retrieved by DAC.
-// Describes a VMPTR_DomainFile representing a module.
+// Describes a VMPTR_DomainAssembly representing a module.
 // In the VM, a raw Module may be domain neutral and shared by many appdomains.
-// Whereas a DomainFile is like a { AppDomain, Module} pair. DomainFile corresponds
+// Whereas a DomainAssembly is like a { AppDomain, Module} pair. DomainAssembly corresponds
 // much more to ICorDebugModule (which also has appdomain affinity).
 //===================================================================================
-struct MSLAYOUT DomainFileInfo
+struct MSLAYOUT DomainAssemblyInfo
 {
-    // The appdomain that the DomainFile is associated with.
-    // Although VMPTR_Module may be shared across multiple domains, a DomainFile has appdomain affinity.
+    // The appdomain that the DomainAssembly is associated with.
+    // Although VMPTR_Module may be shared across multiple domains, a DomainAssembly has appdomain affinity.
     VMPTR_AppDomain vmAppDomain;
 
     // The assembly this module belongs to. All modules live in an assembly.
@@ -624,7 +624,7 @@ class MSLAYOUT EnCHangingFieldInfo
               mdFieldDef       fieldToken,
               CorElementType   elementType,
               mdTypeDef        metadataToken,
-              VMPTR_DomainFile vmDomainFile);
+              VMPTR_DomainAssembly vmDomainAssembly);
 
     DebuggerIPCE_BasicTypeData GetObjectTypeData() const { return m_objectTypeData; };
     mdFieldDef GetFieldToken() const { return m_fldToken; };
@@ -660,7 +660,7 @@ enum AreValueTypesBoxed { NoValueTypeBoxing, OnlyPrimitivesUnboxed, AllBoxed };
 typedef struct MSLAYOUT
 {
     // domain file for the type
-    VMPTR_DomainFile vmDomainFile;
+    VMPTR_DomainAssembly vmDomainAssembly;
     // metadata token for the type. This may be a typeRef (for requests) or a typeDef (for responses).
     mdToken          typeToken;
 } TypeRefData;
@@ -746,7 +746,7 @@ struct MSLAYOUT DacGcReference
 struct MSLAYOUT DacExceptionCallStackData
 {
     VMPTR_AppDomain vmAppDomain;
-    VMPTR_DomainFile vmDomainFile;
+    VMPTR_DomainAssembly vmDomainAssembly;
     CORDB_ADDRESS ip;
     mdMethodDef methodDef;
     BOOL isLastForeignExceptionFrame;
diff --git a/src/coreclr/debug/inc/dacdbistructures.inl b/src/coreclr/debug/inc/dacdbistructures.inl
index f9c0404b659c47..84dd2343198633 100644
--- a/src/coreclr/debug/inc/dacdbistructures.inl
+++ b/src/coreclr/debug/inc/dacdbistructures.inl
@@ -712,14 +712,14 @@ void EnCHangingFieldInfo::Init(VMPTR_Object     pObject,
                                mdFieldDef       fieldToken,
                                CorElementType   elementType,
                                mdTypeDef        metadataToken,
-                               VMPTR_DomainFile vmDomainFile)
+                               VMPTR_DomainAssembly vmDomainAssembly)
     {
         m_vmObject = pObject;
         m_offsetToVars = offset;
         m_fldToken = fieldToken;
         m_objectTypeData.elementType = elementType;
         m_objectTypeData.metadataToken = metadataToken;
-        m_objectTypeData.vmDomainFile = vmDomainFile;
+        m_objectTypeData.vmDomainAssembly = vmDomainAssembly;
     }
 
 
diff --git a/src/coreclr/debug/inc/dbgipcevents.h b/src/coreclr/debug/inc/dbgipcevents.h
index 39b34cb56b9655..e433532c29a16f 100644
--- a/src/coreclr/debug/inc/dbgipcevents.h
+++ b/src/coreclr/debug/inc/dbgipcevents.h
@@ -822,15 +822,13 @@ typedef VMPTR_Base<DT_CONTEXT, PTR_CONTEXT> VMPTR_CONTEXT;
 typedef VMPTR_Base<DT_CONTEXT, void > VMPTR_CONTEXT;
 #endif
 
-// DomainFile is a base-class for a CLR module, with app-domain affinity.
-// For domain-neutral modules (like CoreLib), there is a DomainFile instance
+// DomainAssembly is a base-class for a CLR module, with app-domain affinity.
+// For domain-neutral modules (like CoreLib), there is a DomainAssembly instance
 // for each appdomain the module lives in.
 // This is the canonical handle ICorDebug uses to a CLR module.
-DEFINE_VMPTR(class DomainFile,      PTR_DomainFile,     VMPTR_DomainFile);
+DEFINE_VMPTR(class DomainAssembly,  PTR_DomainAssembly, VMPTR_DomainAssembly);
 DEFINE_VMPTR(class Module,          PTR_Module,         VMPTR_Module);
 
-// DomainAssembly derives from DomainFile and represents a manifest module.
-DEFINE_VMPTR(class DomainAssembly,  PTR_DomainAssembly, VMPTR_DomainAssembly);
 DEFINE_VMPTR(class Assembly,        PTR_Assembly,       VMPTR_Assembly);
 
 DEFINE_VMPTR(class PEAssembly,      PTR_PEAssembly,     VMPTR_PEAssembly);
@@ -1260,7 +1258,7 @@ inline bool IsEqualOrCloserToRoot(FramePointer fp1, FramePointer fp2)
 struct MSLAYOUT DebuggerIPCE_FuncData
 {
     mdMethodDef funcMetadataToken;
-    VMPTR_DomainFile vmDomainFile;
+    VMPTR_DomainAssembly vmDomainAssembly;
 
     mdTypeDef   classMetadataToken;
 
@@ -1400,7 +1398,7 @@ struct MSLAYOUT DebuggerIPCE_STRData
         struct MSLAYOUT
         {
             mdMethodDef funcMetadataToken;
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             VMPTR_MethodDesc vmMethodDesc;
             CorDebugInternalFrameType frameType;
         } stubFrame;
@@ -1444,7 +1442,7 @@ struct MSLAYOUT DebuggerIPCE_BasicTypeData
     CorElementType  elementType;
     mdTypeDef       metadataToken;
     VMPTR_Module     vmModule;
-    VMPTR_DomainFile vmDomainFile;
+    VMPTR_DomainAssembly vmDomainAssembly;
     VMPTR_TypeHandle vmTypeHandle;
 };
 
@@ -1480,7 +1478,7 @@ struct MSLAYOUT DebuggerIPCE_ExpandedTypeData
          {
             mdTypeDef       metadataToken;
             VMPTR_Module vmModule;
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             VMPTR_TypeHandle typeHandle; // if non-null then further fetches will be needed to get type arguments
         } ClassTypeData;
 
@@ -1654,7 +1652,7 @@ struct MSLAYOUT DebuggerIPCE_FuncEvalInfo
     DebuggerIPCE_FuncEvalType  funcEvalType;
     mdMethodDef                funcMetadataToken;
     mdTypeDef                  funcClassMetadataToken;
-    VMPTR_DomainFile           vmDomainFile;
+    VMPTR_DomainAssembly       vmDomainAssembly;
     RSPTR_CORDBEVAL            funcEvalKey;
     bool                       evalDuringException;
 
@@ -1892,7 +1890,7 @@ struct MSLAYOUT DebuggerIPCEvent
         {
             // Module whos metadata is being updated
             // This tells the RS that the metadata for that module has become invalid.
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
 
         } MetadataUpdateData;
 
@@ -1935,13 +1933,13 @@ struct MSLAYOUT DebuggerIPCEvent
         struct MSLAYOUT
         {
             // Module that was just loaded.
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
         }LoadModuleData;
 
 
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             LSPTR_ASSEMBLY debuggerAssemblyToken;
         } UnloadModuleData;
 
@@ -1950,7 +1948,7 @@ struct MSLAYOUT DebuggerIPCEvent
         // Queury PDB from OOP
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
         } UpdateModuleSymsData;
 
         DebuggerMDANotification MDANotification;
@@ -1959,7 +1957,7 @@ struct MSLAYOUT DebuggerIPCEvent
         {
             LSPTR_BREAKPOINT breakpointToken;
             mdMethodDef  funcMetadataToken;
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             bool         isIL;
             SIZE_T       offset;
             SIZE_T       encVersion;
@@ -2039,7 +2037,7 @@ struct MSLAYOUT DebuggerIPCEvent
         // Apply an EnC edit
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;      // Module to edit
+            VMPTR_DomainAssembly vmDomainAssembly;      // Module to edit
             DWORD cbDeltaMetadata;              // size of blob pointed to by pDeltaMetadata
             CORDB_ADDRESS pDeltaMetadata;       // pointer to delta metadata in debuggee
                                                 // it's the RS's responsibility to allocate and free
@@ -2056,20 +2054,20 @@ struct MSLAYOUT DebuggerIPCEvent
         struct MSLAYOUT
         {
             mdTypeDef   classMetadataToken;
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             LSPTR_ASSEMBLY classDebuggerAssemblyToken;
         } LoadClass;
 
         struct MSLAYOUT
         {
             mdTypeDef   classMetadataToken;
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             LSPTR_ASSEMBLY classDebuggerAssemblyToken;
         } UnloadClass;
 
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             bool  flag;
         } SetClassLoad;
 
@@ -2100,7 +2098,7 @@ struct MSLAYOUT DebuggerIPCEvent
             CORDB_ADDRESS    startAddress;
             bool             fCanSetIPOnly;
             VMPTR_Thread     vmThreadToken;
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             mdMethodDef      mdMethod;
             VMPTR_MethodDesc vmMethodDesc;
             SIZE_T           offset;
@@ -2129,7 +2127,7 @@ struct MSLAYOUT DebuggerIPCEvent
         struct MSLAYOUT
         {
             // Domain file for the domain in which the notification occurred
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
 
             // metadata token for the type of the CustomNotification object's type
             mdTypeDef    classToken;
@@ -2194,7 +2192,7 @@ struct MSLAYOUT DebuggerIPCEvent
 
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             BOOL             fAllowJitOpts;
             BOOL             fEnableEnC;
         } JitDebugInfo;
@@ -2202,7 +2200,7 @@ struct MSLAYOUT DebuggerIPCEvent
         // EnC Remap opportunity
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             mdMethodDef funcMetadataToken ;        // methodDef of function with remap opportunity
             SIZE_T          currentVersionNumber;  // version currently executing
             SIZE_T          resumeVersionNumber;   // latest version
@@ -2214,7 +2212,7 @@ struct MSLAYOUT DebuggerIPCEvent
         // EnC Remap has taken place
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             mdMethodDef funcMetadataToken;         // methodDef of function that was remapped
         } EnCRemapComplete;
 
@@ -2222,7 +2220,7 @@ struct MSLAYOUT DebuggerIPCEvent
         // specific edit made by EnC (function add/update or field add).
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             mdToken         memberMetadataToken;   // Either a methodDef token indicating the function that
                                                    // was updated/added, or a fieldDef token indicating the
                                                    // field which was added.
@@ -2243,7 +2241,7 @@ struct MSLAYOUT DebuggerIPCEvent
         // @todo - Perhaps we can bundle these up so we can set multiple funcs w/ 1 event?
         struct MSLAYOUT
         {
-            VMPTR_DomainFile vmDomainFile;
+            VMPTR_DomainAssembly vmDomainAssembly;
             mdMethodDef     funcMetadataToken;
             DWORD           dwStatus;
         } SetJMCFunctionStatus;
diff --git a/src/coreclr/inc/vptr_list.h b/src/coreclr/inc/vptr_list.h
index ad17ef35a3b609..d8e6cd42bd7c34 100644
--- a/src/coreclr/inc/vptr_list.h
+++ b/src/coreclr/inc/vptr_list.h
@@ -23,7 +23,6 @@ VPTR_CLASS(ReflectionModule)
 VPTR_CLASS(AppDomain)
 VPTR_CLASS(SystemDomain)
 
-VPTR_CLASS(DomainAssembly)
 VPTR_CLASS(PrecodeStubManager)
 VPTR_CLASS(StubLinkStubManager)
 VPTR_CLASS(ThePreStubManager)
@@ -39,7 +38,6 @@ VPTR_CLASS(DelegateInvokeStubManager)
 VPTR_CLASS(TailCallStubManager)
 #endif
 VPTR_CLASS(CallCountingStubManager)
-VPTR_CLASS(PEAssembly)
 
 VPTR_CLASS(PEImageLayout)
 VPTR_CLASS(ConvertedImageLayout)
diff --git a/src/coreclr/nativeaot/Runtime/eventtrace.cpp b/src/coreclr/nativeaot/Runtime/eventtrace.cpp
index 23dd9726b5ed2d..0f4646152165b1 100644
--- a/src/coreclr/nativeaot/Runtime/eventtrace.cpp
+++ b/src/coreclr/nativeaot/Runtime/eventtrace.cpp
@@ -35,9 +35,9 @@
 #define Win32EventWrite EventWrite
 
 // Flags used to store some runtime information for Event Tracing
-BOOL g_fEEOtherStartup=FALSE;
-BOOL g_fEEComActivatedStartup=FALSE;
-LPCGUID g_fEEComObjectGuid=&GUID_NULL;
+BOOL g_fEEOtherStartup = FALSE;
+BOOL g_fEEComActivatedStartup = FALSE;
+LPCGUID g_fEEComObjectGuid = &GUID_NULL;
 
 BOOL g_fEEHostedStartup = FALSE;
 
@@ -188,16 +188,16 @@ BOOL IsRuntimeNgenKeywordEnabledAndNotSuppressed()
     LIMITED_METHOD_CONTRACT;
 
     return
-    (
-        ETW_TRACING_CATEGORY_ENABLED(
-            MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
-            TRACE_LEVEL_INFORMATION,
-            CLR_NGEN_KEYWORD)
-        && ! ( ETW_TRACING_CATEGORY_ENABLED(
+        (
+            ETW_TRACING_CATEGORY_ENABLED(
                 MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                 TRACE_LEVEL_INFORMATION,
-                CLR_OVERRIDEANDSUPPRESSNGENEVENTS_KEYWORD) )
-    );
+                CLR_NGEN_KEYWORD)
+            && !(ETW_TRACING_CATEGORY_ENABLED(
+                MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+                TRACE_LEVEL_INFORMATION,
+                CLR_OVERRIDEANDSUPPRESSNGENEVENTS_KEYWORD))
+            );
 }
 
 // Same as above, but for the rundown provider
@@ -206,16 +206,16 @@ BOOL IsRundownNgenKeywordEnabledAndNotSuppressed()
     LIMITED_METHOD_CONTRACT;
 
     return
-    (
-        ETW_TRACING_CATEGORY_ENABLED(
-            MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
-            TRACE_LEVEL_INFORMATION,
-            CLR_RUNDOWNNGEN_KEYWORD)
-        && ! ( ETW_TRACING_CATEGORY_ENABLED(
+        (
+            ETW_TRACING_CATEGORY_ENABLED(
+                MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+                TRACE_LEVEL_INFORMATION,
+                CLR_RUNDOWNNGEN_KEYWORD)
+            && !(ETW_TRACING_CATEGORY_ENABLED(
                 MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                 TRACE_LEVEL_INFORMATION,
-                CLR_RUNDOWNOVERRIDEANDSUPPRESSNGENEVENTS_KEYWORD) )
-    );
+                CLR_RUNDOWNOVERRIDEANDSUPPRESSNGENEVENTS_KEYWORD))
+            );
 }
 
 /*******************************************************/
@@ -226,7 +226,7 @@ extern "C"
 {
     CallStackFrame* GetEbp()
     {
-        CallStackFrame *frame=NULL;
+        CallStackFrame* frame = NULL;
         __asm
         {
             mov frame, ebp
@@ -244,8 +244,8 @@ extern "C"
 void ETW::SamplingLog::Append(SIZE_T currentFrame)
 {
     LIMITED_METHOD_CONTRACT;
-    if(m_FrameCount < (ETW::SamplingLog::s_MaxStackSize-1) &&
-       currentFrame != 0)
+    if (m_FrameCount < (ETW::SamplingLog::s_MaxStackSize - 1) &&
+        currentFrame != 0)
     {
         m_EBPStack[m_FrameCount] = currentFrame;
         m_FrameCount++;
@@ -255,7 +255,7 @@ void ETW::SamplingLog::Append(SIZE_T currentFrame)
 /********************************************************/
 /* Function to get the callstack on the current thread  */
 /********************************************************/
-ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::GetCurrentThreadsCallStack(UINT32 *frameCount, PVOID **Stack)
+ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::GetCurrentThreadsCallStack(UINT32* frameCount, PVOID** Stack)
 {
     CONTRACTL
     {
@@ -278,17 +278,17 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::GetCurrentThreadsCallStac
 
     // this not really needed, but let's do it
     // because we use the framecount while dumping the stack event
-    for(int i=m_FrameCount; i<ETW::SamplingLog::s_MaxStackSize; i++)
+    for (int i = m_FrameCount; i < ETW::SamplingLog::s_MaxStackSize; i++)
     {
         m_EBPStack[i] = 0;
     }
     // This is for consumers to work correctly because the number of
     // frames in the manifest file is specified to be 2
-    if(m_FrameCount < 2)
+    if (m_FrameCount < 2)
         m_FrameCount = 2;
 
     *frameCount = m_FrameCount;
-    *Stack = (PVOID *)m_EBPStack;
+    *Stack = (PVOID*)m_EBPStack;
     return stackwalkStatus;
 };
 
@@ -323,7 +323,7 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::SaveCurrentStack(int skip
         return ETW::SamplingLog::UnInitialized;
     }
 #endif // !TARGET_X86 && !TARGET_ARM
-    Thread *pThread = GetThread();
+    Thread* pThread = GetThread();
     if (pThread == NULL)
     {
         return ETW::SamplingLog::UnInitialized;
@@ -341,15 +341,15 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::SaveCurrentStack(int skip
     EX_TRY
     {
 #ifdef TARGET_X86
-        CallStackFrame *currentEBP = GetEbp();
-        CallStackFrame *lastEBP = NULL;
-        while(currentEBP)
+        CallStackFrame * currentEBP = GetEbp();
+        CallStackFrame* lastEBP = NULL;
+        while (currentEBP)
         {
             lastEBP = currentEBP;
             currentEBP = currentEBP->m_Next;
 
             // Skip the top N frames
-            if(skipTopNFrames) {
+            if (skipTopNFrames) {
                 skipTopNFrames--;
                 continue;
             }
@@ -358,16 +358,16 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::SaveCurrentStack(int skip
             Append(lastEBP->m_ReturnAddress);
 
             // Check for stack limits
-            if((SIZE_T)currentEBP < (SIZE_T)Thread::GetStackLowerBound() || (SIZE_T)currentEBP > (SIZE_T)Thread::GetStackUpperBound())
+            if ((SIZE_T)currentEBP < (SIZE_T)Thread::GetStackLowerBound() || (SIZE_T)currentEBP >(SIZE_T)Thread::GetStackUpperBound())
             {
                 break;
             }
 
             // If we have a too small address, we are probably bad
-            if((SIZE_T)currentEBP < (SIZE_T)0x10000)
+            if ((SIZE_T)currentEBP < (SIZE_T)0x10000)
                 break;
 
-            if((SIZE_T)currentEBP < (SIZE_T)lastEBP)
+            if ((SIZE_T)currentEBP < (SIZE_T)lastEBP)
             {
                 break;
             }
@@ -378,7 +378,7 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::SaveCurrentStack(int skip
         UINT_PTR ControlPc = 0;
         UINT_PTR CurrentSP = 0, PrevSP = 0;
 
-        while(1)
+        while (1)
         {
             // Unwind to the caller
             ControlPc = Thread::VirtualUnwindCallFrame(&ctx);
@@ -387,13 +387,13 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::SaveCurrentStack(int skip
             CurrentSP = (UINT_PTR)GetSP(&ctx);
 
             // when to break from this loop
-            if ( ControlPc == 0 || ( PrevSP == CurrentSP ) )
+            if (ControlPc == 0 || (PrevSP == CurrentSP))
             {
                 break;
             }
 
             // Skip the top N frames
-            if ( skipTopNFrames ) {
+            if (skipTopNFrames) {
                 skipTopNFrames--;
                 continue;
             }
@@ -404,7 +404,7 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::SaveCurrentStack(int skip
             PrevSP = CurrentSP;
         }
 #endif //TARGET_X86
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
     pThread->MarkEtwStackWalkCompleted();
 #endif //!DACCESS_COMPILE
 
@@ -431,7 +431,7 @@ ETW::SamplingLog::EtwStackWalkStatus ETW::SamplingLog::SaveCurrentStack(int skip
 /***************************************************************************/
 /* This function should be called from the event tracing callback routine
    when the private CLR provider is enabled */
-/***************************************************************************/
+   /***************************************************************************/
 
 #ifndef FEATURE_REDHAWK
 
@@ -440,13 +440,13 @@ void ETW::GCLog::GCSettingsEvent()
     if (GCHeapUtilities::IsGCHeapInitialized())
     {
         if (ETW_TRACING_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context,
-                                                 GCSettings))
+            GCSettings))
         {
             ETW::GCLog::ETW_GC_INFO Info;
 
-            Info.GCSettings.ServerGC = GCHeapUtilities::IsServerHeap ();
-            Info.GCSettings.SegmentSize = GCHeapUtilities::GetGCHeap()->GetValidSegmentSize (FALSE);
-            Info.GCSettings.LargeObjectSegmentSize = GCHeapUtilities::GetGCHeap()->GetValidSegmentSize (TRUE);
+            Info.GCSettings.ServerGC = GCHeapUtilities::IsServerHeap();
+            Info.GCSettings.SegmentSize = GCHeapUtilities::GetGCHeap()->GetValidSegmentSize(FALSE);
+            Info.GCSettings.LargeObjectSegmentSize = GCHeapUtilities::GetGCHeap()->GetValidSegmentSize(TRUE);
             FireEtwGCSettings_V1(Info.GCSettings.SegmentSize, Info.GCSettings.LargeObjectSegmentSize, Info.GCSettings.ServerGC, GetClrInstanceId());
         }
         GCHeapUtilities::GetGCHeap()->TraceGCSegments();
@@ -518,13 +518,13 @@ struct EtwGcMovementContext
     // else, a new EtwGcMovementContext is allocated, stored in that pointer, and
     // then returned. Callers should test for NULL, which can be returned if out of
     // memory
-    static EtwGcMovementContext * GetOrCreateInGCContext(EtwGcMovementContext ** ppContext)
+    static EtwGcMovementContext* GetOrCreateInGCContext(EtwGcMovementContext** ppContext)
     {
         LIMITED_METHOD_CONTRACT;
 
         _ASSERTE(ppContext != NULL);
 
-        EtwGcMovementContext * pContext = *ppContext;
+        EtwGcMovementContext* pContext = *ppContext;
         if (pContext == NULL)
         {
             pContext = new (nothrow) EtwGcMovementContext;
@@ -597,13 +597,13 @@ struct MovedReferenceContextForEtwAndProfapi
     // returned; else, a new MovedReferenceContextForEtwAndProfapi is allocated, stored
     // in that pointer, and then returned. Callers should test for NULL, which can be
     // returned if out of memory
-    static MovedReferenceContextForEtwAndProfapi * CreateInGCContext(LPVOID pvContext)
+    static MovedReferenceContextForEtwAndProfapi* CreateInGCContext(LPVOID pvContext)
     {
         LIMITED_METHOD_CONTRACT;
 
         _ASSERTE(pvContext != NULL);
 
-        MovedReferenceContextForEtwAndProfapi * pContext = *(MovedReferenceContextForEtwAndProfapi **) pvContext;
+        MovedReferenceContextForEtwAndProfapi* pContext = *(MovedReferenceContextForEtwAndProfapi**)pvContext;
 
         // Shouldn't be called if the context was already created.  Perhaps someone made
         // one too many BeginMovedReferences calls, or didn't have an EndMovedReferences
@@ -611,7 +611,7 @@ struct MovedReferenceContextForEtwAndProfapi
         _ASSERTE(pContext == NULL);
 
         pContext = new (nothrow) MovedReferenceContextForEtwAndProfapi;
-        *(MovedReferenceContextForEtwAndProfapi **) pvContext = pContext;
+        *(MovedReferenceContextForEtwAndProfapi**)pvContext = pContext;
 
         return pContext;
     }
@@ -626,7 +626,7 @@ struct MovedReferenceContextForEtwAndProfapi
     }
 
     LPVOID pctxProfAPI;
-    EtwGcMovementContext * pctxEtw;
+    EtwGcMovementContext* pctxEtw;
 };
 
 
@@ -648,8 +648,8 @@ struct MovedReferenceContextForEtwAndProfapi
 
 // static
 void ETW::GCLog::MovedReference(
-    BYTE * pbMemBlockStart,
-    BYTE * pbMemBlockEnd,
+    BYTE* pbMemBlockStart,
+    BYTE* pbMemBlockEnd,
     ptrdiff_t cbRelocDistance,
     size_t profilingContext,
     BOOL fCompacting,
@@ -665,8 +665,8 @@ void ETW::GCLog::MovedReference(
     }
     CONTRACTL_END;
 
-    MovedReferenceContextForEtwAndProfapi * pCtxForEtwAndProfapi =
-        (MovedReferenceContextForEtwAndProfapi *) profilingContext;
+    MovedReferenceContextForEtwAndProfapi* pCtxForEtwAndProfapi =
+        (MovedReferenceContextForEtwAndProfapi*)profilingContext;
     if (pCtxForEtwAndProfapi == NULL)
     {
         _ASSERTE(!"MovedReference() encountered a NULL profilingContext");
@@ -678,10 +678,10 @@ void ETW::GCLog::MovedReference(
     {
         BEGIN_PIN_PROFILER(CORProfilerTrackGC());
         g_profControlBlock.pProfInterface->MovedReference(pbMemBlockStart,
-                                                          pbMemBlockEnd,
-                                                          cbRelocDistance,
-                                                          &(pCtxForEtwAndProfapi->pctxProfAPI),
-                                                          fCompacting);
+            pbMemBlockEnd,
+            cbRelocDistance,
+            &(pCtxForEtwAndProfapi->pctxProfAPI),
+            fCompacting);
         END_PIN_PROFILER();
     }
 #endif // PROFILING_SUPPORTED
@@ -691,7 +691,7 @@ void ETW::GCLog::MovedReference(
     if (!ShouldTrackMovementForEtw())
         return;
 
-    EtwGcMovementContext * pContext =
+    EtwGcMovementContext* pContext =
         EtwGcMovementContext::GetOrCreateInGCContext(&pCtxForEtwAndProfapi->pctxEtw);
     if (pContext == NULL)
         return;
@@ -701,7 +701,7 @@ void ETW::GCLog::MovedReference(
         // Moved references
 
         _ASSERTE(pContext->cBulkMovedObjectRanges < _countof(pContext->rgGCBulkMovedObjectRanges));
-        EventStructGCBulkMovedObjectRangesValue * pValue =
+        EventStructGCBulkMovedObjectRangesValue* pValue =
             &pContext->rgGCBulkMovedObjectRanges[pContext->cBulkMovedObjectRanges];
         pValue->OldRangeBase = pbMemBlockStart;
         pValue->NewRangeBase = pbMemBlockStart + cbRelocDistance;
@@ -727,7 +727,7 @@ void ETW::GCLog::MovedReference(
         // Surviving references
 
         _ASSERTE(pContext->cBulkSurvivingObjectRanges < _countof(pContext->rgGCBulkSurvivingObjectRanges));
-        EventStructGCBulkSurvivingObjectRangesValue * pValue =
+        EventStructGCBulkSurvivingObjectRangesValue* pValue =
             &pContext->rgGCBulkSurvivingObjectRanges[pContext->cBulkSurvivingObjectRanges];
         pValue->RangeBase = pbMemBlockStart;
         pValue->RangeLength = pbMemBlockEnd - pbMemBlockStart;
@@ -763,7 +763,7 @@ void ETW::GCLog::MovedReference(
 //
 
 // static
-void ETW::GCLog::BeginMovedReferences(size_t * pProfilingContext)
+void ETW::GCLog::BeginMovedReferences(size_t* pProfilingContext)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -794,7 +794,7 @@ void ETW::GCLog::EndMovedReferences(size_t profilingContext,
     }
     CONTRACTL_END;
 
-    MovedReferenceContextForEtwAndProfapi * pCtxForEtwAndProfapi = (MovedReferenceContextForEtwAndProfapi *) profilingContext;
+    MovedReferenceContextForEtwAndProfapi* pCtxForEtwAndProfapi = (MovedReferenceContextForEtwAndProfapi*)profilingContext;
     if (pCtxForEtwAndProfapi == NULL)
     {
         _ASSERTE(!"EndMovedReferences() encountered a NULL profilingContext");
@@ -817,7 +817,7 @@ void ETW::GCLog::EndMovedReferences(size_t profilingContext,
 
     // If context isn't already set up for us, then we haven't been collecting any data
     // for ETW events.
-    EtwGcMovementContext * pContext = pCtxForEtwAndProfapi->pctxEtw;
+    EtwGcMovementContext* pContext = pCtxForEtwAndProfapi->pctxEtw;
     if (pContext == NULL)
         return;
 
@@ -893,7 +893,7 @@ void ETW::GCLog::ForceGC(LONGLONG l64ClientSequenceNumber)
 //
 
 // static
-void ETW::GCLog::FireGcStart(ETW_GC_INFO * pGcInfo)
+void ETW::GCLog::FireGcStart(ETW_GC_INFO* pGcInfo)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -924,7 +924,7 @@ void ETW::GCLog::FireGcStart(ETW_GC_INFO * pGcInfo)
         FireEtwGCStart_V2(pGcInfo->GCStart.Count, pGcInfo->GCStart.Depth, pGcInfo->GCStart.Reason, pGcInfo->GCStart.Type, GetClrInstanceId(), l64ClientSequenceNumberToLog);
 
 #elif defined(FEATURE_DTRACE)
-        FireEtwGCStart(pGcInfo->GCStart.Count,pGcInfo->GCStart.Reason);
+        FireEtwGCStart(pGcInfo->GCStart.Count, pGcInfo->GCStart.Reason);
 #endif
     }
 
@@ -990,7 +990,7 @@ HRESULT ETW::GCLog::ForceGCForDiagnostics()
         _ASSERTE(GCHeapUtilities::IsGCHeapInitialized());
 
         ThreadStore::AttachCurrentThread();
-        Thread * pThread = ThreadStore::GetCurrentThread();
+        Thread* pThread = ThreadStore::GetCurrentThread();
 
         // Doing this prevents the GC from trying to walk this thread's stack for roots.
         pThread->SetGCSpecial(true);
@@ -1011,11 +1011,11 @@ HRESULT ETW::GCLog::ForceGCForDiagnostics()
         pThread->EnablePreemptiveMode();
 #else   // !FEATURE_REDHAWK
     }
-    EX_CATCH { }
-    EX_END_CATCH(RethrowCorruptingExceptions);
+EX_CATCH{ }
+EX_END_CATCH(RethrowCorruptingExceptions);
 #endif // FEATURE_REDHAWK
 
-    return hr;
+return hr;
 }
 
 
@@ -1142,7 +1142,7 @@ void BulkTypeEventLogger::FireBulkTypeEvent()
 #ifdef FEATURE_REDHAWK
                 ((m_rgBulkTypeValues[iTypeData].cTypeParameters == 1) ?
                     &(m_rgBulkTypeValues[iTypeData].ullSingleTypeParameter) :
-                    (ULONGLONG *) (m_rgBulkTypeValues[iTypeData].rgTypeParameters)),
+                    (ULONGLONG*)(m_rgBulkTypeValues[iTypeData].rgTypeParameters)),
 #else
                 m_rgBulkTypeValues[iTypeData].rgTypeParameters.GetElements(),
 #endif
@@ -1200,7 +1200,7 @@ int BulkTypeEventLogger::LogSingleType(TypeHandle th)
         return -1;
     }
 
-    BulkTypeValue * pVal = &m_rgBulkTypeValues[m_nBulkTypeValueCount];
+    BulkTypeValue* pVal = &m_rgBulkTypeValues[m_nBulkTypeValueCount];
 
     // Clear out pVal before filling it out (array elements can get reused if there
     // are enough types that we need to flush to multiple events).  Clearing the
@@ -1211,7 +1211,7 @@ int BulkTypeEventLogger::LogSingleType(TypeHandle th)
         pVal->Clear();
         fSucceeded = TRUE;
     }
-    EX_CATCH
+        EX_CATCH
     {
         fSucceeded = FALSE;
     }
@@ -1219,11 +1219,11 @@ int BulkTypeEventLogger::LogSingleType(TypeHandle th)
     if (!fSucceeded)
         return -1;
 
-    pVal->fixedSizedData.TypeID = (ULONGLONG) th.AsTAddr();
-    pVal->fixedSizedData.ModuleID = (ULONGLONG) (TADDR) th.GetModule();
+    pVal->fixedSizedData.TypeID = (ULONGLONG)th.AsTAddr();
+    pVal->fixedSizedData.ModuleID = (ULONGLONG)(TADDR)th.GetModule();
     pVal->fixedSizedData.TypeNameID = (th.GetMethodTable() == NULL) ? 0 : th.GetCl();
     pVal->fixedSizedData.Flags = 0;
-    pVal->fixedSizedData.CorElementType = (BYTE) th.GetInternalCorElementType();
+    pVal->fixedSizedData.CorElementType = (BYTE)th.GetInternalCorElementType();
 
     if (th.IsArray())
     {
@@ -1234,10 +1234,10 @@ int BulkTypeEventLogger::LogSingleType(TypeHandle th)
         fSucceeded = FALSE;
         EX_TRY
         {
-            pVal->rgTypeParameters.Append((ULONGLONG) th.AsArray()->GetArrayElementTypeHandle().AsTAddr());
+            pVal->rgTypeParameters.Append((ULONGLONG)th.AsArray()->GetArrayElementTypeHandle().AsTAddr());
             fSucceeded = TRUE;
         }
-        EX_CATCH
+            EX_CATCH
         {
             fSucceeded = FALSE;
         }
@@ -1254,10 +1254,10 @@ int BulkTypeEventLogger::LogSingleType(TypeHandle th)
             fSucceeded = FALSE;
             EX_TRY
             {
-                pVal->rgTypeParameters.Append((ULONGLONG) pTypeDesc->GetTypeParam().AsTAddr());
+                pVal->rgTypeParameters.Append((ULONGLONG)pTypeDesc->GetTypeParam().AsTAddr());
                 fSucceeded = TRUE;
             }
-            EX_CATCH
+                EX_CATCH
             {
                 fSucceeded = FALSE;
             }
@@ -1290,13 +1290,13 @@ int BulkTypeEventLogger::LogSingleType(TypeHandle th)
             fSucceeded = FALSE;
             EX_TRY
             {
-                for (DWORD i=0; i < cTypeParameters; i++)
+                for (DWORD i = 0; i < cTypeParameters; i++)
                 {
-                    pVal->rgTypeParameters.Append((ULONGLONG) inst[i].AsTAddr());
+                    pVal->rgTypeParameters.Append((ULONGLONG)inst[i].AsTAddr());
                 }
                 fSucceeded = TRUE;
             }
-            EX_CATCH
+                EX_CATCH
             {
                 fSucceeded = FALSE;
             }
@@ -1332,7 +1332,7 @@ int BulkTypeEventLogger::LogSingleType(TypeHandle th)
         }
         pVal->sName.Normalize();
     }
-    EX_CATCH
+        EX_CATCH
     {
         // If this failed, the name remains empty, which is ok; the event just
         // won't have a name in it.
@@ -1397,7 +1397,7 @@ void BulkTypeEventLogger::LogTypeAndParameters(ULONGLONG thAsAddr, ETW::TypeSyst
     }
     CONTRACTL_END;
 
-    TypeHandle th = TypeHandle::FromTAddr((TADDR) thAsAddr);
+    TypeHandle th = TypeHandle::FromTAddr((TADDR)thAsAddr);
 
     // Batch up this type.  This grabs useful info about the type, including any
     // type parameters it may have, and sticks it in m_rgBulkTypeValues
@@ -1410,7 +1410,7 @@ void BulkTypeEventLogger::LogTypeAndParameters(ULONGLONG thAsAddr, ETW::TypeSyst
     }
 
     // Look at the type info we just batched, so we can get the type parameters
-    BulkTypeValue * pVal = &m_rgBulkTypeValues[iBulkTypeEventData];
+    BulkTypeValue* pVal = &m_rgBulkTypeValues[iBulkTypeEventData];
 
     // We're about to recursively call ourselves for the type parameters, so make a
     // local copy of their type handles first (else, as we log them we could flush
@@ -1428,7 +1428,7 @@ void BulkTypeEventLogger::LogTypeAndParameters(ULONGLONG thAsAddr, ETW::TypeSyst
         }
         fSucceeded = TRUE;
     }
-    EX_CATCH
+        EX_CATCH
     {
         fSucceeded = FALSE;
     }
@@ -1443,7 +1443,7 @@ void BulkTypeEventLogger::LogTypeAndParameters(ULONGLONG thAsAddr, ETW::TypeSyst
         typeLogBehavior = ETW::TypeSystemLog::kTypeLogBehaviorAssumeLockAndLogIfFirstTime;
 
     // Recursively log any referenced parameter types
-    for (COUNT_T i=0; i < cParams; i++)
+    for (COUNT_T i = 0; i < cParams; i++)
     {
         ETW::TypeSystemLog::LogTypeAndParametersIfNecessary(this, rgTypeParameters[i], typeLogBehavior);
     }
@@ -1463,13 +1463,13 @@ class EtwGcHeapDumpContext
     // ProfilerWalkHeapContext::pvEtwContext; if non-NULL it gets returned; else, a new
     // EtwGcHeapDumpContext is allocated, stored in that pointer, and then returned.
     // Callers should test for NULL, which can be returned if out of memory
-    static EtwGcHeapDumpContext * GetOrCreateInGCContext(LPVOID * ppvEtwContext)
+    static EtwGcHeapDumpContext* GetOrCreateInGCContext(LPVOID* ppvEtwContext)
     {
         LIMITED_METHOD_CONTRACT;
 
         _ASSERTE(ppvEtwContext != NULL);
 
-        EtwGcHeapDumpContext * pContext = (EtwGcHeapDumpContext *) *ppvEtwContext;
+        EtwGcHeapDumpContext* pContext = (EtwGcHeapDumpContext*)*ppvEtwContext;
         if (pContext == NULL)
         {
             pContext = new (nothrow) EtwGcHeapDumpContext;
@@ -1644,10 +1644,10 @@ class EtwGcHeapDumpContext
 // static
 void ETW::GCLog::RootReference(
     LPVOID pvHandle,
-    Object * pRootedNode,
-    Object * pSecondaryNodeForDependentHandle,
+    Object* pRootedNode,
+    Object* pSecondaryNodeForDependentHandle,
     BOOL fDependentHandle,
-    ProfilingScanContext * profilingScanContext,
+    ProfilingScanContext* profilingScanContext,
     DWORD dwGCFlags,
     DWORD rootFlags)
 {
@@ -1657,14 +1657,14 @@ void ETW::GCLog::RootReference(
     if (pRootedNode == NULL)
         return;
 
-    EtwGcHeapDumpContext * pContext =
+    EtwGcHeapDumpContext* pContext =
         EtwGcHeapDumpContext::GetOrCreateInGCContext(&profilingScanContext->pvEtwContext);
     if (pContext == NULL)
         return;
 
     // Determine root kind, root ID, and handle-specific flags
     LPVOID pvRootID = NULL;
-    BYTE nRootKind = (BYTE) profilingScanContext->dwEtwRootKind;
+    BYTE nRootKind = (BYTE)profilingScanContext->dwEtwRootKind;
     switch (nRootKind)
     {
     case kEtwGCRootKindStack:
@@ -1699,7 +1699,7 @@ void ETW::GCLog::RootReference(
     {
         _ASSERTE(pContext->cGCBulkRootConditionalWeakTableElementEdges <
             _countof(pContext->rgGCBulkRootConditionalWeakTableElementEdges));
-        EventStructGCBulkRootConditionalWeakTableElementEdgeValue * pRCWTEEdgeValue =
+        EventStructGCBulkRootConditionalWeakTableElementEdgeValue* pRCWTEEdgeValue =
             &pContext->rgGCBulkRootConditionalWeakTableElementEdges[pContext->cGCBulkRootConditionalWeakTableElementEdges];
         pRCWTEEdgeValue->GCKeyNodeID = pRootedNode;
         pRCWTEEdgeValue->GCValueNodeID = pSecondaryNodeForDependentHandle;
@@ -1724,7 +1724,7 @@ void ETW::GCLog::RootReference(
     else
     {
         _ASSERTE(pContext->cGcBulkRootEdges < _countof(pContext->rgGcBulkRootEdges));
-        EventStructGCBulkRootEdgeValue * pBulkRootEdgeValue = &pContext->rgGcBulkRootEdges[pContext->cGcBulkRootEdges];
+        EventStructGCBulkRootEdgeValue* pBulkRootEdgeValue = &pContext->rgGcBulkRootEdges[pContext->cGcBulkRootEdges];
         pBulkRootEdgeValue->RootedNodeAddress = pRootedNode;
         pBulkRootEdgeValue->GCRootKind = nRootKind;
         pBulkRootEdgeValue->GCRootFlag = rootFlags;
@@ -1765,11 +1765,11 @@ void ETW::GCLog::RootReference(
 
 // static
 void ETW::GCLog::ObjectReference(
-    ProfilerWalkHeapContext * profilerWalkHeapContext,
-    Object * pObjReferenceSource,
+    ProfilerWalkHeapContext* profilerWalkHeapContext,
+    Object* pObjReferenceSource,
     ULONGLONG typeID,
     ULONGLONG cRefs,
-    Object ** rgObjReferenceTargets)
+    Object** rgObjReferenceTargets)
 {
 #ifndef WINXP_AND_WIN2K3_BUILD_SUPPORT
     CONTRACTL
@@ -1783,7 +1783,7 @@ void ETW::GCLog::ObjectReference(
     }
     CONTRACTL_END;
 
-    EtwGcHeapDumpContext * pContext =
+    EtwGcHeapDumpContext* pContext =
         EtwGcHeapDumpContext::GetOrCreateInGCContext(&profilerWalkHeapContext->pvEtwContext);
     if (pContext == NULL)
         return;
@@ -1794,7 +1794,7 @@ void ETW::GCLog::ObjectReference(
 
     // Add Node (pObjReferenceSource) to buffer
     _ASSERTE(pContext->cGcBulkNodeValues < _countof(pContext->rgGcBulkNodeValues));
-    EventStructGCBulkNodeValue * pBulkNodeValue = &pContext->rgGcBulkNodeValues[pContext->cGcBulkNodeValues];
+    EventStructGCBulkNodeValue* pBulkNodeValue = &pContext->rgGcBulkNodeValues[pContext->cGcBulkNodeValues];
     pBulkNodeValue->Address = pObjReferenceSource;
     pBulkNodeValue->Size = pObjReferenceSource->GetSize();
     pBulkNodeValue->TypeID = typeID;
@@ -1830,7 +1830,7 @@ void ETW::GCLog::ObjectReference(
             // During heap walk, GC holds the lock for us, so we can directly enter the
             // hash to see if the type has already been logged
             ETW::TypeSystemLog::kTypeLogBehaviorAssumeLockAndLogIfFirstTime
-            );
+        );
     }
 
     //---------------------------------------------------------------------------------------
@@ -1842,10 +1842,10 @@ void ETW::GCLog::ObjectReference(
     // a lot of edges), so empty Edge buffer into ETW as we go along, as many times as we
     // need.
 
-    for (ULONGLONG i=0; i < cRefs; i++)
+    for (ULONGLONG i = 0; i < cRefs; i++)
     {
         _ASSERTE(pContext->cGcBulkEdgeValues < _countof(pContext->rgGcBulkEdgeValues));
-        EventStructGCBulkEdgeValue * pBulkEdgeValue = &pContext->rgGcBulkEdgeValues[pContext->cGcBulkEdgeValues];
+        EventStructGCBulkEdgeValue* pBulkEdgeValue = &pContext->rgGcBulkEdgeValues[pContext->cGcBulkEdgeValues];
         pBulkEdgeValue->Value = rgObjReferenceTargets[i];
         // FUTURE: ReferencingFieldID
         pBulkEdgeValue->ReferencingFieldID = 0;
@@ -1878,14 +1878,14 @@ void ETW::GCLog::ObjectReference(
 //
 
 // static
-void ETW::GCLog::EndHeapDump(ProfilerWalkHeapContext * profilerWalkHeapContext)
+void ETW::GCLog::EndHeapDump(ProfilerWalkHeapContext* profilerWalkHeapContext)
 {
 #ifndef WINXP_AND_WIN2K3_BUILD_SUPPORT
     LIMITED_METHOD_CONTRACT;
 
     // If context isn't already set up for us, then we haven't been collecting any data
     // for ETW events.
-    EtwGcHeapDumpContext * pContext = (EtwGcHeapDumpContext *) profilerWalkHeapContext->pvEtwContext;
+    EtwGcHeapDumpContext* pContext = (EtwGcHeapDumpContext*)profilerWalkHeapContext->pvEtwContext;
     if (pContext == NULL)
         return;
 
@@ -1969,7 +1969,7 @@ void ETW::GCLog::EndHeapDump(ProfilerWalkHeapContext * profilerWalkHeapContext)
 //
 
 // static
-void ETW::GCLog::SendFinalizeObjectEvent(MethodTable * pMT, Object * pObj)
+void ETW::GCLog::SendFinalizeObjectEvent(MethodTable* pMT, Object* pObj)
 {
     CONTRACTL
     {
@@ -1991,12 +1991,12 @@ void ETW::GCLog::SendFinalizeObjectEvent(MethodTable * pMT, Object * pObj)
         // finalized object's type (and parameter types, if any)
         ETW::TypeSystemLog::LogTypeAndParametersIfNecessary(
             NULL,       // Not batching this type with others
-            (TADDR) pMT,
+            (TADDR)pMT,
 
             // Don't spend the time entering the lock and checking the hash table to see
             // if we've already logged the type; just log it (if type events are enabled).
             ETW::TypeSystemLog::kTypeLogBehaviorAlwaysLog
-            );
+        );
     }
 
     // Send private finalize object event, if it's enabled
@@ -2007,14 +2007,14 @@ void ETW::GCLog::SendFinalizeObjectEvent(MethodTable * pMT, Object * pObj)
             DefineFullyQualifiedNameForClassWOnStack();
             FireEtwPrvFinalizeObject(pMT, pObj, GetClrInstanceId(), GetFullyQualifiedNameForClassNestedAwareW(pMT));
         }
-        EX_CATCH
+            EX_CATCH
         {
         }
         EX_END_CATCH(RethrowCorruptingExceptions);
     }
 }
 
-DWORD ETW::ThreadLog::GetEtwThreadFlags(Thread * pThread)
+DWORD ETW::ThreadLog::GetEtwThreadFlags(Thread* pThread)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -2037,7 +2037,7 @@ DWORD ETW::ThreadLog::GetEtwThreadFlags(Thread * pThread)
     return dwEtwThreadFlags;
 }
 
-void ETW::ThreadLog::FireThreadCreated(Thread * pThread)
+void ETW::ThreadLog::FireThreadCreated(Thread* pThread)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -2050,7 +2050,7 @@ void ETW::ThreadLog::FireThreadCreated(Thread * pThread)
         GetClrInstanceId());
 }
 
-void ETW::ThreadLog::FireThreadDC(Thread * pThread)
+void ETW::ThreadLog::FireThreadDC(Thread* pThread)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -2088,7 +2088,7 @@ class LoggedTypesFromModuleTraits : public NoRemoveSHashTraits< DefaultSHashTrai
 
     typedef TypeHandle key_t;
 
-    static key_t GetKey(const element_t &e)
+    static key_t GetKey(const element_t& e)
     {
         LIMITED_METHOD_CONTRACT;
         return e.th;
@@ -2103,10 +2103,10 @@ class LoggedTypesFromModuleTraits : public NoRemoveSHashTraits< DefaultSHashTrai
     static count_t Hash(key_t k)
     {
         LIMITED_METHOD_CONTRACT;
-        return (count_t) k.AsTAddr();
+        return (count_t)k.AsTAddr();
     }
 
-    static bool IsNull(const element_t &e)
+    static bool IsNull(const element_t& e)
     {
         LIMITED_METHOD_CONTRACT;
         return (e.th.AsTAddr() == NULL);
@@ -2125,23 +2125,23 @@ typedef SHash<LoggedTypesFromModuleTraits> LoggedTypesFromModuleHash;
 class ETW::LoggedTypesFromModule
 {
 public:
-    Module * pModule;
+    Module* pModule;
     LoggedTypesFromModuleHash loggedTypesFromModuleHash;
 
     // These are used by the outer hash table (mapping Module*'s to instances of
     // LoggedTypesFromModule).
-    static COUNT_T Hash(Module * pModule)
+    static COUNT_T Hash(Module* pModule)
     {
         LIMITED_METHOD_CONTRACT;
-        return (COUNT_T) (SIZE_T) pModule;
+        return (COUNT_T)(SIZE_T)pModule;
     }
-    Module * GetKey()
+    Module* GetKey()
     {
         LIMITED_METHOD_CONTRACT;
         return pModule;
     }
 
-    LoggedTypesFromModule(Module * pModuleParam) : loggedTypesFromModuleHash()
+    LoggedTypesFromModule(Module* pModuleParam) : loggedTypesFromModuleHash()
     {
         LIMITED_METHOD_CONTRACT;
         pModule = pModuleParam;
@@ -2156,19 +2156,19 @@ class ETW::LoggedTypesFromModule
 // The following define the outer hash table (mapping Module*'s to instances of
 // LoggedTypesFromModule).
 
-class AllLoggedTypesTraits : public DefaultSHashTraits<ETW::LoggedTypesFromModule *>
+class AllLoggedTypesTraits : public DefaultSHashTraits<ETW::LoggedTypesFromModule*>
 {
 public:
 
     // explicitly declare local typedefs for these traits types, otherwise
     // the compiler may get confused
-    typedef DefaultSHashTraits<ETW::LoggedTypesFromModule *> PARENT;
+    typedef DefaultSHashTraits<ETW::LoggedTypesFromModule*> PARENT;
     typedef PARENT::element_t element_t;
     typedef PARENT::count_t count_t;
 
-    typedef Module * key_t;
+    typedef Module* key_t;
 
-    static key_t GetKey(const element_t &e)
+    static key_t GetKey(const element_t& e)
     {
         LIMITED_METHOD_CONTRACT;
         return e->pModule;
@@ -2183,10 +2183,10 @@ class AllLoggedTypesTraits : public DefaultSHashTraits<ETW::LoggedTypesFromModul
     static count_t Hash(key_t k)
     {
         LIMITED_METHOD_CONTRACT;
-        return (count_t) (size_t) k;
+        return (count_t)(size_t)k;
     }
 
-    static bool IsNull(const element_t &e)
+    static bool IsNull(const element_t& e)
     {
         LIMITED_METHOD_CONTRACT;
         return (e == NULL);
@@ -2219,7 +2219,7 @@ struct AllLoggedTypes
 
 
 CrstStatic AllLoggedTypes::s_cs;
-AllLoggedTypes * ETW::TypeSystemLog::s_pAllLoggedTypes = NULL;
+AllLoggedTypes* ETW::TypeSystemLog::s_pAllLoggedTypes = NULL;
 BOOL ETW::TypeSystemLog::s_fHeapAllocEventEnabledOnStartup = FALSE;
 BOOL ETW::TypeSystemLog::s_fHeapAllocHighEventEnabledNow = FALSE;
 BOOL ETW::TypeSystemLog::s_fHeapAllocLowEventEnabledNow = FALSE;
@@ -2299,7 +2299,7 @@ void ETW::TypeSystemLog::PostRegistrationInit()
             wszCustomObjectAllocationEventsPerTypePerSec,
             &endPtr,
             10          // Base 10 conversion
-            );
+        );
 
         if (dwCustomObjectAllocationEventsPerTypePerSec == ULONG_MAX)
             dwCustomObjectAllocationEventsPerTypePerSec = 0;
@@ -2414,7 +2414,7 @@ BOOL ETW::TypeSystemLog::IsHeapAllocEventEnabled()
 //
 
 // static
-BOOL ETW::TypeSystemLog::AddOrReplaceTypeLoggingInfo(ETW::LoggedTypesFromModule * pLoggedTypesFromModule, const ETW::TypeLoggingInfo * pTypeLoggingInfo)
+BOOL ETW::TypeSystemLog::AddOrReplaceTypeLoggingInfo(ETW::LoggedTypesFromModule* pLoggedTypesFromModule, const ETW::TypeLoggingInfo* pTypeLoggingInfo)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -2427,7 +2427,7 @@ BOOL ETW::TypeSystemLog::AddOrReplaceTypeLoggingInfo(ETW::LoggedTypesFromModule
         pLoggedTypesFromModule->loggedTypesFromModuleHash.AddOrReplace(*pTypeLoggingInfo);
         fSucceeded = TRUE;
     }
-    EX_CATCH
+        EX_CATCH
     {
         fSucceeded = FALSE;
     }
@@ -2447,7 +2447,7 @@ BOOL ETW::TypeSystemLog::AddOrReplaceTypeLoggingInfo(ETW::LoggedTypesFromModule
 //
 
 // static
-void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object * pObject)
+void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object* pObject)
 {
     CONTRACTL
     {
@@ -2465,7 +2465,7 @@ void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object * pObject)
     TypeHandle th = pObject->GetTypeHandle();
 
     SIZE_T size = pObject->GetSize();
-    if(size < MIN_OBJECT_SIZE)
+    if (size < MIN_OBJECT_SIZE)
     {
         size = PtrAlign(size);
     }
@@ -2481,7 +2481,7 @@ void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object * pObject)
 
         // Get stats for type
         TypeLoggingInfo typeLoggingInfo(NULL);
-        LoggedTypesFromModule * pLoggedTypesFromModule = NULL;
+        LoggedTypesFromModule* pLoggedTypesFromModule = NULL;
         BOOL fCreatedNew = FALSE;
         typeLoggingInfo = LookupOrCreateTypeLoggingInfo(th, &fCreatedNew, &pLoggedTypesFromModule);
         if (typeLoggingInfo.th.IsNull())
@@ -2524,19 +2524,19 @@ void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object * pObject)
         int nMinAllocPerMSec = typeLoggingInfo.dwAllocCountInCurrentBucket / 16;		// This is an underestimation of the true rate.
         if (delta >= 16 || (nMinAllocPerMSec > 2 && nMinAllocPerMSec > typeLoggingInfo.flAllocPerMSec * 1.5F))
         {
-            float flNewAllocPerMSec  = 0;
+            float flNewAllocPerMSec = 0;
             if (delta >= 16)
             {
                 // This is the normal case, our allocation rate is under control with the current throttling.
-                flNewAllocPerMSec  = ((float) typeLoggingInfo.dwAllocCountInCurrentBucket) / delta;
+                flNewAllocPerMSec = ((float)typeLoggingInfo.dwAllocCountInCurrentBucket) / delta;
                 // Do a exponential decay window that is 5 * max(16, AllocationInterval)
-                typeLoggingInfo.flAllocPerMSec = 0.8F *  typeLoggingInfo.flAllocPerMSec + 0.2F * flNewAllocPerMSec;
+                typeLoggingInfo.flAllocPerMSec = 0.8F * typeLoggingInfo.flAllocPerMSec + 0.2F * flNewAllocPerMSec;
                 typeLoggingInfo.dwTickOfCurrentTimeBucket = dwTickNow;
                 typeLoggingInfo.dwAllocCountInCurrentBucket = 0;
             }
             else
             {
-                flNewAllocPerMSec = (float) nMinAllocPerMSec;
+                flNewAllocPerMSec = (float)nMinAllocPerMSec;
                 // This means the second clause above is true, which means our sampling rate is too low
                 // so we need to throttle quickly.
                 typeLoggingInfo.flAllocPerMSec = flNewAllocPerMSec;
@@ -2546,7 +2546,7 @@ void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object * pObject)
             // Obey the desired sampling rate, but don't ignore > 1000 allocations per second
             // per type
             int nDesiredMsBetweenEvents = (s_nCustomMsBetweenEvents == 0) ? GetDefaultMsBetweenEvents() : s_nCustomMsBetweenEvents;
-            typeLoggingInfo.dwAllocsToSkipPerSample = min((int) (typeLoggingInfo.flAllocPerMSec * nDesiredMsBetweenEvents), 1000);
+            typeLoggingInfo.dwAllocsToSkipPerSample = min((int)(typeLoggingInfo.flAllocPerMSec * nDesiredMsBetweenEvents), 1000);
             if (typeLoggingInfo.dwAllocsToSkipPerSample == 1)
                 typeLoggingInfo.dwAllocsToSkipPerSample = 0;
         }
@@ -2586,11 +2586,11 @@ void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object * pObject)
     // Now log the allocation
     if (s_fHeapAllocHighEventEnabledNow)
     {
-        FireEtwGCSampledObjectAllocationHigh(pObject, (LPVOID) th.AsTAddr(), dwObjectCountForTypeSample, nTotalSizeForTypeSample, GetClrInstanceId());
+        FireEtwGCSampledObjectAllocationHigh(pObject, (LPVOID)th.AsTAddr(), dwObjectCountForTypeSample, nTotalSizeForTypeSample, GetClrInstanceId());
     }
     else
     {
-        FireEtwGCSampledObjectAllocationLow(pObject, (LPVOID) th.AsTAddr(), dwObjectCountForTypeSample, nTotalSizeForTypeSample, GetClrInstanceId());
+        FireEtwGCSampledObjectAllocationLow(pObject, (LPVOID)th.AsTAddr(), dwObjectCountForTypeSample, nTotalSizeForTypeSample, GetClrInstanceId());
     }
 }
 
@@ -2603,7 +2603,7 @@ void ETW::TypeSystemLog::SendObjectAllocatedEvent(Object * pObject)
 //
 
 // static
-CrstBase * ETW::TypeSystemLog::GetHashCrst()
+CrstBase* ETW::TypeSystemLog::GetHashCrst()
 {
     LIMITED_METHOD_CONTRACT;
     return &AllLoggedTypes::s_cs;
@@ -2629,7 +2629,7 @@ CrstBase * ETW::TypeSystemLog::GetHashCrst()
 //
 
 // static
-void ETW::TypeSystemLog::LogTypeAndParametersIfNecessary(BulkTypeEventLogger * pLogger, ULONGLONG thAsAddr, TypeLogBehavior typeLogBehavior)
+void ETW::TypeSystemLog::LogTypeAndParametersIfNecessary(BulkTypeEventLogger* pLogger, ULONGLONG thAsAddr, TypeLogBehavior typeLogBehavior)
 {
     CONTRACTL
     {
@@ -2650,7 +2650,7 @@ void ETW::TypeSystemLog::LogTypeAndParametersIfNecessary(BulkTypeEventLogger * p
         return;
     }
 
-    TypeHandle th = TypeHandle::FromTAddr((TADDR) thAsAddr);
+    TypeHandle th = TypeHandle::FromTAddr((TADDR)thAsAddr);
     if (!th.IsRestored())
     {
         return;
@@ -2661,11 +2661,11 @@ void ETW::TypeSystemLog::LogTypeAndParametersIfNecessary(BulkTypeEventLogger * p
     // through to the logging code below.  If caller doesn't care, then don't even
     // check; just log the type
     BOOL fShouldLogType = ((typeLogBehavior == kTypeLogBehaviorAlwaysLog) ||
-                           (typeLogBehavior == kTypeLogBehaviorAssumeLockAndAlwaysLogTopLevelType)) ?
-                           TRUE :
-                           ((typeLogBehavior == kTypeLogBehaviorTakeLockAndLogIfFirstTime) ?
-                               ShouldLogType(th) :
-                               ShouldLogTypeNoLock(th));
+        (typeLogBehavior == kTypeLogBehaviorAssumeLockAndAlwaysLogTopLevelType)) ?
+        TRUE :
+        ((typeLogBehavior == kTypeLogBehaviorTakeLockAndLogIfFirstTime) ?
+            ShouldLogType(th) :
+            ShouldLogTypeNoLock(th));
     if (!fShouldLogType)
         return;
 
@@ -2767,7 +2767,7 @@ BOOL ETW::TypeSystemLog::ShouldLogTypeNoLock(TypeHandle th)
 //
 
 // static
-ETW::TypeLoggingInfo ETW::TypeSystemLog::LookupOrCreateTypeLoggingInfo(TypeHandle th, BOOL * pfCreatedNew, LoggedTypesFromModule ** ppLoggedTypesFromModule /* = NULL */)
+ETW::TypeLoggingInfo ETW::TypeSystemLog::LookupOrCreateTypeLoggingInfo(TypeHandle th, BOOL* pfCreatedNew, LoggedTypesFromModule** ppLoggedTypesFromModule /* = NULL */)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -2794,9 +2794,9 @@ ETW::TypeLoggingInfo ETW::TypeSystemLog::LookupOrCreateTypeLoggingInfo(TypeHandl
 
     // Step 1: go from LoaderModule to hash of types.
 
-    Module * pLoaderModule = th.GetLoaderModule();
+    Module* pLoaderModule = th.GetLoaderModule();
     _ASSERTE(pLoaderModule != NULL);
-    LoggedTypesFromModule * pLoggedTypesFromModule = s_pAllLoggedTypes->allLoggedTypesHash.Lookup(pLoaderModule);
+    LoggedTypesFromModule* pLoggedTypesFromModule = s_pAllLoggedTypes->allLoggedTypesHash.Lookup(pLoaderModule);
     if (pLoggedTypesFromModule == NULL)
     {
         pLoggedTypesFromModule = new (nothrow) LoggedTypesFromModule(pLoaderModule);
@@ -2813,7 +2813,7 @@ ETW::TypeLoggingInfo ETW::TypeSystemLog::LookupOrCreateTypeLoggingInfo(TypeHandl
             s_pAllLoggedTypes->allLoggedTypesHash.Add(pLoggedTypesFromModule);
             fSucceeded = TRUE;
         }
-        EX_CATCH
+            EX_CATCH
         {
             fSucceeded = FALSE;
         }
@@ -2850,7 +2850,7 @@ ETW::TypeLoggingInfo ETW::TypeSystemLog::LookupOrCreateTypeLoggingInfo(TypeHandl
         pLoggedTypesFromModule->loggedTypesFromModuleHash.Add(typeLoggingInfoNew);
         fSucceeded = TRUE;
     }
-    EX_CATCH
+        EX_CATCH
     {
         fSucceeded = FALSE;
     }
@@ -2876,7 +2876,7 @@ ETW::TypeLoggingInfo ETW::TypeSystemLog::LookupOrCreateTypeLoggingInfo(TypeHandl
 //
 
 // static
-void ETW::TypeSystemLog::OnModuleUnload(Module * pModule)
+void ETW::TypeSystemLog::OnModuleUnload(Module* pModule)
 {
     CONTRACTL
     {
@@ -2895,7 +2895,7 @@ void ETW::TypeSystemLog::OnModuleUnload(Module * pModule)
         return;
     }
 
-    LoggedTypesFromModule * pLoggedTypesFromModule = NULL;
+    LoggedTypesFromModule* pLoggedTypesFromModule = NULL;
 
     {
         CrstHolder _crst(GetHashCrst());
@@ -2943,12 +2943,12 @@ void ETW::TypeSystemLog::OnTypesKeywordTurnedOff()
         return;
 
     // Destruct each of the per-module TypesHashes
-    AllLoggedTypesHash * pLoggedTypesHash = &s_pAllLoggedTypes->allLoggedTypesHash;
+    AllLoggedTypesHash* pLoggedTypesHash = &s_pAllLoggedTypes->allLoggedTypesHash;
     for (AllLoggedTypesHash::Iterator iter = pLoggedTypesHash->Begin();
-         iter != pLoggedTypesHash->End();
-         ++iter)
+        iter != pLoggedTypesHash->End();
+        ++iter)
     {
-        LoggedTypesFromModule * pLoggedTypesFromModule = *iter;
+        LoggedTypesFromModule* pLoggedTypesFromModule = *iter;
         delete pLoggedTypesFromModule;
     }
 
@@ -2962,10 +2962,10 @@ void ETW::TypeSystemLog::OnTypesKeywordTurnedOff()
 /****************************************************************************/
 /* Called when ETW is turned ON on an existing process and ModuleRange events are to
      be fired */
-/****************************************************************************/
+     /****************************************************************************/
 void ETW::EnumerationLog::ModuleRangeRundown()
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
@@ -2978,7 +2978,7 @@ void ETW::EnumerationLog::ModuleRangeRundown()
         {
             ETW::EnumerationLog::EnumerationHelper(NULL, NULL, ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoadPrivate);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
@@ -2986,7 +2986,7 @@ void ETW::EnumerationLog::ModuleRangeRundown()
 /****************************************************************************/
 void ETW::EnumerationLog::StartRundown()
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
@@ -3004,7 +3004,7 @@ void ETW::EnumerationLog::StartRundown()
             TRACE_LEVEL_INFORMATION,
             CLR_RUNDOWNTHREADING_KEYWORD);
 
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         CLR_RUNDOWNJIT_KEYWORD)
            ||
@@ -3028,30 +3028,30 @@ void ETW::EnumerationLog::StartRundown()
             FireEtwDCStartInit_V1(GetClrInstanceId());
 
             // The rundown flag is expected to be checked in the caller, so no need to check here again
-            DWORD enumerationOptions=ETW::EnumerationLog::EnumerationStructs::None;
-            if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+            DWORD enumerationOptions = ETW::EnumerationLog::EnumerationStructs::None;
+            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                             TRACE_LEVEL_INFORMATION,
                                             CLR_RUNDOWNLOADER_KEYWORD))
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart;
             }
-            if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                             TRACE_LEVEL_INFORMATION,
                                             CLR_RUNDOWNJIT_KEYWORD))
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::JitMethodDCStart;
             }
-            if(IsRundownNgenKeywordEnabledAndNotSuppressed())
+            if (IsRundownNgenKeywordEnabledAndNotSuppressed())
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::NgenMethodDCStart;
             }
-            if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                             TRACE_LEVEL_INFORMATION,
                                             CLR_RUNDOWNJITTEDMETHODILTONATIVEMAP_KEYWORD))
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::MethodDCStartILToNativeMap;
             }
-            if(bIsPerfTrackRundownEnabled)
+            if (bIsPerfTrackRundownEnabled)
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCStart;
             }
@@ -3076,7 +3076,7 @@ void ETW::EnumerationLog::StartRundown()
             // end marker event will go to the rundown provider
             FireEtwDCStartComplete_V1(GetClrInstanceId());
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 //---------------------------------------------------------------------------------------
@@ -3094,26 +3094,26 @@ DWORD ETW::EnumerationLog::GetEnumerationOptionsFromRuntimeKeywords()
 {
     LIMITED_METHOD_CONTRACT;
 
-    DWORD enumerationOptions=ETW::EnumerationLog::EnumerationStructs::None;
-    if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+    DWORD enumerationOptions = ETW::EnumerationLog::EnumerationStructs::None;
+    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
         TRACE_LEVEL_INFORMATION,
         CLR_LOADER_KEYWORD))
     {
         enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload;
     }
-    if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
         TRACE_LEVEL_INFORMATION,
         CLR_JIT_KEYWORD) &&
         ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
-        TRACE_LEVEL_INFORMATION,
-        CLR_ENDENUMERATION_KEYWORD))
+            TRACE_LEVEL_INFORMATION,
+            CLR_ENDENUMERATION_KEYWORD))
     {
         enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::JitMethodUnload;
     }
-    if(IsRuntimeNgenKeywordEnabledAndNotSuppressed() &&
+    if (IsRuntimeNgenKeywordEnabledAndNotSuppressed() &&
         ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
-        TRACE_LEVEL_INFORMATION,
-        CLR_ENDENUMERATION_KEYWORD))
+            TRACE_LEVEL_INFORMATION,
+            CLR_ENDENUMERATION_KEYWORD))
     {
         enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::NgenMethodUnload;
     }
@@ -3149,7 +3149,7 @@ void ETW::EnumerationLog::EnumerateForCaptureState()
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, TRACE_LEVEL_INFORMATION, KEYWORDZERO))
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, TRACE_LEVEL_INFORMATION, KEYWORDZERO))
         {
             DWORD enumerationOptions = GetEnumerationOptionsFromRuntimeKeywords();
 
@@ -3165,7 +3165,7 @@ void ETW::EnumerationLog::EnumerateForCaptureState()
                 SendThreadRundownEvent();
             }
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /**************************************************************************************/
@@ -3173,7 +3173,7 @@ void ETW::EnumerationLog::EnumerateForCaptureState()
 /**************************************************************************************/
 void ETW::EnumerationLog::EndRundown()
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
@@ -3187,7 +3187,7 @@ void ETW::EnumerationLog::EndRundown()
             MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
             TRACE_LEVEL_INFORMATION,
             CLR_RUNDOWNTHREADING_KEYWORD);
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         CLR_RUNDOWNJIT_KEYWORD)
            ||
@@ -3210,30 +3210,30 @@ void ETW::EnumerationLog::EndRundown()
             FireEtwDCEndInit_V1(GetClrInstanceId());
 
             // The rundown flag is expected to be checked in the caller, so no need to check here again
-            DWORD enumerationOptions=ETW::EnumerationLog::EnumerationStructs::None;
-            if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+            DWORD enumerationOptions = ETW::EnumerationLog::EnumerationStructs::None;
+            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                             TRACE_LEVEL_INFORMATION,
                                             CLR_RUNDOWNLOADER_KEYWORD))
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd;
             }
-            if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                             TRACE_LEVEL_INFORMATION,
                                             CLR_RUNDOWNJIT_KEYWORD))
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::JitMethodDCEnd;
             }
-            if(IsRundownNgenKeywordEnabledAndNotSuppressed())
+            if (IsRundownNgenKeywordEnabledAndNotSuppressed())
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::NgenMethodDCEnd;
             }
-            if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
                                             TRACE_LEVEL_INFORMATION,
                                             CLR_RUNDOWNJITTEDMETHODILTONATIVEMAP_KEYWORD))
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::MethodDCEndILToNativeMap;
             }
-            if(bIsPerfTrackRundownEnabled)
+            if (bIsPerfTrackRundownEnabled)
             {
                 enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCEnd;
             }
@@ -3248,7 +3248,7 @@ void ETW::EnumerationLog::EndRundown()
             // end marker event will go to the rundown provider
             FireEtwDCEndComplete_V1(GetClrInstanceId());
         }
-    } EX_CATCH {
+    } EX_CATCH{
         STRESS_LOG1(LF_ALWAYS, LL_ERROR, "Exception during Rundown Enumeration, EIP of last AV = %p", g_LastAccessViolationEIP);
     } EX_END_CATCH(SwallowAllExceptions);
 }
@@ -3290,9 +3290,9 @@ void InitializeEventTracing()
     // Register CLR providers with the OS
     if (g_pEtwTracer == NULL)
     {
-        NewHolder <ETW::CEtwTracer> tempEtwTracer (new (nothrow) ETW::CEtwTracer());
-        if (tempEtwTracer != NULL && tempEtwTracer->Register () == ERROR_SUCCESS)
-            g_pEtwTracer = tempEtwTracer.Extract ();
+        NewHolder <ETW::CEtwTracer> tempEtwTracer(new (nothrow) ETW::CEtwTracer());
+        if (tempEtwTracer != NULL && tempEtwTracer->Register() == ERROR_SUCCESS)
+            g_pEtwTracer = tempEtwTracer.Extract();
     }
 
     g_nClrInstanceId = GetRuntimeId() & 0x0000FFFF; // This will give us duplicate ClrInstanceId after UINT16_MAX
@@ -3375,37 +3375,44 @@ HRESULT ETW::CEtwTracer::UnRegister()
 extern "C"
 {
     ETW_INLINE
-    void EtwCallout(REGHANDLE RegHandle,
-                    PCEVENT_DESCRIPTOR Descriptor,
-                    ULONG ArgumentCount,
-                    PEVENT_DATA_DESCRIPTOR EventData)
+        void EtwCallout(REGHANDLE RegHandle,
+            PCEVENT_DESCRIPTOR Descriptor,
+            ULONG ArgumentCount,
+            PEVENT_DATA_DESCRIPTOR EventData)
     {
         WRAPPER_NO_CONTRACT;
         UINT8 providerIndex = 0;
-        if(RegHandle == Microsoft_Windows_DotNETRuntimeHandle) {
+        if (RegHandle == Microsoft_Windows_DotNETRuntimeHandle) {
             providerIndex = 0;
-        } else if(RegHandle == Microsoft_Windows_DotNETRuntimeRundownHandle) {
+        }
+        else if (RegHandle == Microsoft_Windows_DotNETRuntimeRundownHandle) {
             providerIndex = 1;
-        } else if(RegHandle == Microsoft_Windows_DotNETRuntimeStressHandle) {
+        }
+        else if (RegHandle == Microsoft_Windows_DotNETRuntimeStressHandle) {
             providerIndex = 2;
-        } else if(RegHandle == Microsoft_Windows_DotNETRuntimePrivateHandle) {
+        }
+        else if (RegHandle == Microsoft_Windows_DotNETRuntimePrivateHandle) {
             providerIndex = 3;
-        } else {
+        }
+        else {
             _ASSERTE(!"Provider not one of Runtime, Rundown, Private and Stress");
             return;
         }
 
         // stacks are supposed to be fired for only the events with a bit set in the etwStackSupportedEvents bitmap
-        if(((etwStackSupportedEvents[providerIndex][Descriptor->Id/8]) &
-            (1<<(Descriptor->Id%8))) != 0)
+        if (((etwStackSupportedEvents[providerIndex][Descriptor->Id / 8]) &
+            (1 << (Descriptor->Id % 8))) != 0)
         {
-            if(RegHandle == Microsoft_Windows_DotNETRuntimeHandle) {
+            if (RegHandle == Microsoft_Windows_DotNETRuntimeHandle) {
                 ETW::SamplingLog::SendStackTrace(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, &CLRStackWalk, &CLRStackId);
-            } else if(RegHandle == Microsoft_Windows_DotNETRuntimeRundownHandle) {
+            }
+            else if (RegHandle == Microsoft_Windows_DotNETRuntimeRundownHandle) {
                 ETW::SamplingLog::SendStackTrace(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context, &CLRStackWalkDCStart, &CLRStackRundownId);
-            } else if(RegHandle == Microsoft_Windows_DotNETRuntimePrivateHandle) {
+            }
+            else if (RegHandle == Microsoft_Windows_DotNETRuntimePrivateHandle) {
                 ETW::SamplingLog::SendStackTrace(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context, &CLRStackWalkPrivate, &CLRStackPrivateId);
-            } else if(RegHandle == Microsoft_Windows_DotNETRuntimeStressHandle) {
+            }
+            else if (RegHandle == Microsoft_Windows_DotNETRuntimeStressHandle) {
                 ETW::SamplingLog::SendStackTrace(MICROSOFT_WINDOWS_DOTNETRUNTIME_STRESS_PROVIDER_Context, &CLRStackWalkStress, &CLRStackStressId);
             }
         }
@@ -3430,22 +3437,23 @@ extern "C"
     // action in this class, we pass "this" during provider registration and modify the
     // context to the relevant context in the C callback later.
     ETW_INLINE
-    void EtwCallback(
-        _In_ LPCGUID SourceId,
-        _In_ ULONG ControlCode,
-        _In_ UCHAR Level,
-        _In_ ULONGLONG MatchAnyKeyword,
-        _In_ ULONGLONG MatchAllKeyword,
-        _In_opt_ PEVENT_FILTER_DESCRIPTOR FilterData,
-        _Inout_opt_ PVOID CallbackContext)
-    {
-        CONTRACTL {
+        void EtwCallback(
+            _In_ LPCGUID SourceId,
+            _In_ ULONG ControlCode,
+            _In_ UCHAR Level,
+            _In_ ULONGLONG MatchAnyKeyword,
+            _In_ ULONGLONG MatchAllKeyword,
+            _In_opt_ PEVENT_FILTER_DESCRIPTOR FilterData,
+            _Inout_opt_ PVOID CallbackContext)
+    {
+        CONTRACTL{
             NOTHROW;
-            if(g_fEEStarted) {GC_TRIGGERS;} else {DISABLED(GC_NOTRIGGER);};
-            MODE_ANY;
-            CAN_TAKE_LOCK;
-            STATIC_CONTRACT_FAULT;
-            SO_NOT_MAINLINE;
+            if (g_fEEStarted) { GC_TRIGGERS; }
+ else { DISABLED(GC_NOTRIGGER); };
+MODE_ANY;
+CAN_TAKE_LOCK;
+STATIC_CONTRACT_FAULT;
+SO_NOT_MAINLINE;
         } CONTRACTL_END;
 
         // Mark that we are the special ETWRundown thread.  Currently all this does
@@ -3459,21 +3467,21 @@ extern "C"
 
         BOOLEAN bIsPublicTraceHandle =
 #ifdef WINXP_AND_WIN2K3_BUILD_SUPPORT
-            McGenPreVista ? ((ULONGLONG)Microsoft_Windows_DotNETRuntimeHandle==(ULONGLONG)context) :
+            McGenPreVista ? ((ULONGLONG)Microsoft_Windows_DotNETRuntimeHandle == (ULONGLONG)context) :
 #endif
-            (context->RegistrationHandle==Microsoft_Windows_DotNETRuntimeHandle);
+            (context->RegistrationHandle == Microsoft_Windows_DotNETRuntimeHandle);
 
         BOOLEAN bIsPrivateTraceHandle =
 #ifdef WINXP_AND_WIN2K3_BUILD_SUPPORT
-            McGenPreVista ? ((ULONGLONG)Microsoft_Windows_DotNETRuntimePrivateHandle==(ULONGLONG)context) :
+            McGenPreVista ? ((ULONGLONG)Microsoft_Windows_DotNETRuntimePrivateHandle == (ULONGLONG)context) :
 #endif
-            (context->RegistrationHandle==Microsoft_Windows_DotNETRuntimePrivateHandle);
+            (context->RegistrationHandle == Microsoft_Windows_DotNETRuntimePrivateHandle);
 
         BOOLEAN bIsRundownTraceHandle =
 #ifdef WINXP_AND_WIN2K3_BUILD_SUPPORT
-            McGenPreVista ? ((ULONGLONG)Microsoft_Windows_DotNETRuntimeRundownHandle==(ULONGLONG)context) :
+            McGenPreVista ? ((ULONGLONG)Microsoft_Windows_DotNETRuntimeRundownHandle == (ULONGLONG)context) :
 #endif
-            (context->RegistrationHandle==Microsoft_Windows_DotNETRuntimeRundownHandle);
+            (context->RegistrationHandle == Microsoft_Windows_DotNETRuntimeRundownHandle);
 
 
         // A manifest based provider can be enabled to multiple event tracing sessions
@@ -3482,8 +3490,8 @@ extern "C"
         // IsEnabled will be TRUE when it is enabled and FALSE when disabled
         BOOL bEnabled =
             ((ControlCode == EVENT_CONTROL_CODE_ENABLE_PROVIDER) ||
-             (ControlCode == EVENT_CONTROL_CODE_CAPTURE_STATE));
-        if(bEnabled)
+                (ControlCode == EVENT_CONTROL_CODE_CAPTURE_STATE));
+        if (bEnabled)
         {
             // TypeSystemLog needs a notification when certain keywords are modified, so
             // give it a hook here.
@@ -3495,7 +3503,7 @@ extern "C"
             if (bIsPrivateTraceHandle)
             {
                 ETW::GCLog::GCSettingsEvent();
-                if(g_fEEStarted && !g_fEEShutDown)
+                if (g_fEEStarted && !g_fEEShutDown)
                 {
                     ETW::EnumerationLog::ModuleRangeRundown();
                 }
@@ -3505,10 +3513,10 @@ extern "C"
             // If we have turned on the JIT keyword to the VERBOSE setting (needed to get JIT names) then
             // we assume that we also want good stack traces so we need to publish unwind information so
             // ETW can get at it
-            if(bIsPublicTraceHandle && ETW_CATEGORY_ENABLED((*context), TRACE_LEVEL_VERBOSE, CLR_RUNDOWNJIT_KEYWORD))
+            if (bIsPublicTraceHandle && ETW_CATEGORY_ENABLED((*context), TRACE_LEVEL_VERBOSE, CLR_RUNDOWNJIT_KEYWORD))
                 UnwindInfoTable::PublishUnwindInfo(g_fEEStarted != FALSE);
 #endif
-            if(g_fEEStarted && !g_fEEShutDown && bIsRundownTraceHandle)
+            if (g_fEEStarted && !g_fEEShutDown && bIsRundownTraceHandle)
             {
                 // Fire the runtime information event
                 ETW::InfoLog::RuntimeInformation(ETW::InfoLog::InfoStructs::Callback);
@@ -3516,15 +3524,15 @@ extern "C"
                 // Start and End Method/Module Rundowns
                 // Used to fire events that we missed since we started the controller after the process started
                 // flags for immediate start rundown
-                if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
-                                                TRACE_LEVEL_INFORMATION,
-                                                CLR_RUNDOWNSTART_KEYWORD))
+                if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+                    TRACE_LEVEL_INFORMATION,
+                    CLR_RUNDOWNSTART_KEYWORD))
                     ETW::EnumerationLog::StartRundown();
 
                 // flags delayed end rundown
-                if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
-                                                TRACE_LEVEL_INFORMATION,
-                                                CLR_RUNDOWNEND_KEYWORD))
+                if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
+                    TRACE_LEVEL_INFORMATION,
+                    CLR_RUNDOWNEND_KEYWORD))
                     ETW::EnumerationLog::EndRundown();
             }
 
@@ -3545,7 +3553,7 @@ extern "C"
                     (FilterData->Type == 1) &&
                     (FilterData->Size == sizeof(l64ClientSequenceNumber)))
                 {
-                    l64ClientSequenceNumber = *(LONGLONG *) (FilterData->Ptr);
+                    l64ClientSequenceNumber = *(LONGLONG*)(FilterData->Ptr);
                 }
                 ETW::GCLog::ForceGC(l64ClientSequenceNumber);
             }
@@ -3566,7 +3574,7 @@ extern "C"
 /* in its printf API, we cast the unicode string to UFT8 string and then output them.                                */
 /**************************************************************************************/
 #define DTRACE_OUTPUT_STRING_LEN 512
-const CHAR szDtraceOutputNULL[]="NULL";
+const CHAR szDtraceOutputNULL[] = "NULL";
 INT32 WideCharToMultiByte(LPCWSTR wszSrcStr, LPSTR szDstStr);
 
 #include <rotor_pal.h>
@@ -3586,7 +3594,7 @@ ULONG ETW::CEtwTracer::Register()
     // Get Env Var COMPlus_ETWEnabled
     char szETWEnabled[SIZE_ETWEnabled];
     DWORD newLen = GetEnvironmentVariableA("COMPlus_ETWEnabled", szETWEnabled, SIZE_ETWEnabled);
-    if (newLen  == 0 || newLen >= SIZE_ETWEnabled || strcmp(szETWEnabled, "1") != 0)
+    if (newLen == 0 || newLen >= SIZE_ETWEnabled || strcmp(szETWEnabled, "1") != 0)
         return 0;
 
     // Get Env Var COMPlus_EventInfo
@@ -3621,12 +3629,12 @@ INT32  WideCharToMultiByte(LPCWSTR wszSrcStr, LPSTR szDstStr)
     {
         return 0;
     }
-    if (nSize > DTRACE_OUTPUT_STRING_LEN-1)
+    if (nSize > DTRACE_OUTPUT_STRING_LEN - 1)
     {
-        nSize = DTRACE_OUTPUT_STRING_LEN-1;
+        nSize = DTRACE_OUTPUT_STRING_LEN - 1;
     }
-    INT32 nSize2 =  WideCharToMultiByte(CP_UTF8, 0, wszSrcStr, -1, szDstStr, nSize, NULL, NULL);
-    if(nSize2 != nSize || nSize2 <=0 )
+    INT32 nSize2 = WideCharToMultiByte(CP_UTF8, 0, wszSrcStr, -1, szDstStr, nSize, NULL, NULL);
+    if (nSize2 != nSize || nSize2 <= 0)
     {
         return 0;
     }
@@ -3801,20 +3809,20 @@ void SecurityCatchCallEnd_V1()
 /****************************************************************************/
 /* This is called by the runtime when an exception is thrown */
 /****************************************************************************/
-void ETW::ExceptionLog::ExceptionThrown(CrawlFrame  *pCf, BOOL bIsReThrownException, BOOL bIsNewException)
+void ETW::ExceptionLog::ExceptionThrown(CrawlFrame* pCf, BOOL bIsReThrownException, BOOL bIsNewException)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
         PRECONDITION(GetThread() != NULL);
         PRECONDITION(GetThread()->GetThrowable() != NULL);
     } CONTRACTL_END;
 
-    if(!(bIsReThrownException || bIsNewException))
+    if (!(bIsReThrownException || bIsNewException))
     {
         return;
     }
-    if(!ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, ExceptionThrown_V1))
+    if (!ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, ExceptionThrown_V1))
     {
         return;
     }
@@ -3822,11 +3830,11 @@ void ETW::ExceptionLog::ExceptionThrown(CrawlFrame  *pCf, BOOL bIsReThrownExcept
     {
         SString exceptionType(L"");
         LPWSTR exceptionMessage = NULL;
-        BOOL bIsCLSCompliant=FALSE, bIsCSE=FALSE, bIsNestedException=FALSE, bHasInnerException=FALSE;
-        UINT16 exceptionFlags=0;
-        PVOID exceptionEIP=0;
+        BOOL bIsCLSCompliant = FALSE, bIsCSE = FALSE, bIsNestedException = FALSE, bHasInnerException = FALSE;
+        UINT16 exceptionFlags = 0;
+        PVOID exceptionEIP = 0;
 
-        Thread *pThread = GetThread();
+        Thread* pThread = GetThread();
 
         struct
         {
@@ -3840,7 +3848,7 @@ void ETW::ExceptionLog::ExceptionThrown(CrawlFrame  *pCf, BOOL bIsReThrownExcept
         gc.exceptionObj = pThread->GetThrowable();
         gc.innerExceptionObj = ((EXCEPTIONREF)gc.exceptionObj)->GetInnerException();
 
-        ThreadExceptionState *pExState = pThread->GetExceptionState();
+        ThreadExceptionState* pExState = pThread->GetExceptionState();
 #ifndef WIN64EXCEPTIONS
         PTR_ExInfo pExInfo = NULL;
 #else
@@ -3855,7 +3863,7 @@ void ETW::ExceptionLog::ExceptionThrown(CrawlFrame  *pCf, BOOL bIsReThrownExcept
 
         // A rethrown exception is also a nested exception
         // but since we have a separate flag for it, lets unset the nested flag
-        if(bIsReThrownException)
+        if (bIsReThrownException)
         {
             bIsNestedException = FALSE;
         }
@@ -3887,12 +3895,12 @@ void ETW::ExceptionLog::ExceptionThrown(CrawlFrame  *pCf, BOOL bIsReThrownExcept
             exceptionEIP = (PVOID)((UINT_PTR)exceptionEIP - 1);
         }
 
-        gc.exceptionMessageRef =  ((EXCEPTIONREF)gc.exceptionObj)->GetMessage();
+        gc.exceptionMessageRef = ((EXCEPTIONREF)gc.exceptionObj)->GetMessage();
         TypeHandle exceptionTypeHandle = (gc.exceptionObj)->GetTypeHandle();
         exceptionTypeHandle.GetName(exceptionType);
-        WCHAR *exceptionTypeName = (WCHAR *)exceptionType.GetUnicode();
+        WCHAR* exceptionTypeName = (WCHAR*)exceptionType.GetUnicode();
 
-        if(gc.exceptionMessageRef != NULL)
+        if (gc.exceptionMessageRef != NULL)
         {
             exceptionMessage = (gc.exceptionMessageRef)->GetBuffer();
         }
@@ -3906,53 +3914,53 @@ void ETW::ExceptionLog::ExceptionThrown(CrawlFrame  *pCf, BOOL bIsReThrownExcept
                                   exceptionFlags,
                                   GetClrInstanceId());
         GCPROTECT_END();
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
 /* This is called by the runtime when a domain is loaded */
 /****************************************************************************/
-void ETW::LoaderLog::DomainLoadReal(BaseDomain *pDomain, _In_opt_ LPWSTR wszFriendlyName)
+void ETW::LoaderLog::DomainLoadReal(BaseDomain* pDomain, _In_opt_ LPWSTR wszFriendlyName)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         CLR_LOADER_KEYWORD))
         {
             DWORD dwEventOptions = ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad;
             ETW::LoaderLog::SendDomainEvent(pDomain, dwEventOptions, wszFriendlyName);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
 /* This is called by the runtime when an AppDomain is unloaded */
 /****************************************************************************/
-void ETW::LoaderLog::DomainUnload(AppDomain *pDomain)
+void ETW::LoaderLog::DomainUnload(AppDomain* pDomain)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         KEYWORDZERO))
         {
-            if(!pDomain->NoAccessToHandleTable())
+            if (!pDomain->NoAccessToHandleTable())
             {
                 DWORD enumerationOptions = ETW::EnumerationLog::GetEnumerationOptionsFromRuntimeKeywords();
 
                 // Domain unload also causes type unload events
-                if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+                if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                                 TRACE_LEVEL_INFORMATION,
                                                 CLR_TYPE_KEYWORD))
                 {
@@ -3962,29 +3970,29 @@ void ETW::LoaderLog::DomainUnload(AppDomain *pDomain)
                 ETW::EnumerationLog::EnumerationHelper(NULL, pDomain, enumerationOptions);
             }
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
 /* This is called by the runtime when a LoaderAllocator is unloaded */
 /****************************************************************************/
-void ETW::LoaderLog::CollectibleLoaderAllocatorUnload(AssemblyLoaderAllocator *pLoaderAllocator)
+void ETW::LoaderLog::CollectibleLoaderAllocatorUnload(AssemblyLoaderAllocator* pLoaderAllocator)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         KEYWORDZERO))
         {
             DWORD enumerationOptions = ETW::EnumerationLog::GetEnumerationOptionsFromRuntimeKeywords();
 
             // Collectible Loader Allocator unload also causes type unload events
-            if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+            if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                             TRACE_LEVEL_INFORMATION,
                                             CLR_TYPE_KEYWORD))
             {
@@ -3993,23 +4001,23 @@ void ETW::LoaderLog::CollectibleLoaderAllocatorUnload(AssemblyLoaderAllocator *p
 
             ETW::EnumerationLog::IterateCollectibleLoaderAllocator(pLoaderAllocator, enumerationOptions);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
 /* This is called by the runtime when the runtime is loaded
    Function gets called by both the Callback mechanism and regular ETW events.
    Type is used to differentiate whether its a callback or a normal call*/
-/****************************************************************************/
+   /****************************************************************************/
 void ETW::InfoLog::RuntimeInformation(INT32 type)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
-    EX_TRY {
-        if((type == ETW::InfoLog::InfoStructs::Normal && ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, RuntimeInformationStart))
+    EX_TRY{
+        if ((type == ETW::InfoLog::InfoStructs::Normal && ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, RuntimeInformationStart))
 #ifndef FEATURE_PAL
             ||
            (type == ETW::InfoLog::InfoStructs::Callback && ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context, RuntimeInformationDCStart))
@@ -4017,21 +4025,21 @@ void ETW::InfoLog::RuntimeInformation(INT32 type)
           )
         {
 #ifndef FEATURE_DTRACE
-            PCWSTR szDtraceOutput1=L"",szDtraceOutput2=L"";
+            PCWSTR szDtraceOutput1 = L"",szDtraceOutput2 = L"";
 #else
             CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
             CHAR szDtraceOutput2[DTRACE_OUTPUT_STRING_LEN];
 #endif // !FEATURE_DTRACE
             UINT8 startupMode = 0;
             UINT startupFlags = 0;
-            WCHAR dllPath[MAX_PATH+1] = {0};
+            WCHAR dllPath[MAX_PATH + 1] = {0};
             UINT8 Sku = 0;
             _ASSERTE(g_fEEManagedEXEStartup ||   //CLR started due to a managed exe
                 g_fEEIJWStartup ||               //CLR started as a mixed mode Assembly
                 CLRHosted() || g_fEEHostedStartup || //CLR started through one of the Hosting API CLRHosted() returns true if CLR started through the V2 Interface while
                                                     // g_fEEHostedStartup is true if CLR is hosted through the V1 API.
                 g_fEEComActivatedStartup ||      //CLR started as a COM object
-                g_fEEOtherStartup  );            //In case none of the 4 above mentioned cases are true for example ngen, ildasm then we asssume its a "other" startup
+                g_fEEOtherStartup);            //In case none of the 4 above mentioned cases are true for example ngen, ildasm then we asssume its a "other" startup
 
 #ifdef FEATURE_CORECLR
             Sku = ETW::InfoLog::InfoStructs::CoreCLR;
@@ -4052,9 +4060,9 @@ void ETW::InfoLog::RuntimeInformation(INT32 type)
             USHORT bclQfeVersion = VER_ASSEMBLYBUILD_QFE;
 
 #ifndef FEATURE_PAL
-            LPCGUID comGUID=g_fEEComObjectGuid;
+            LPCGUID comGUID = g_fEEComObjectGuid;
 #else
-            unsigned int comGUID=0;
+            unsigned int comGUID = 0;
 #endif //!FEATURE_PAL
 
 #ifndef FEATURE_DTRACE
@@ -4070,12 +4078,12 @@ void ETW::InfoLog::RuntimeInformation(INT32 type)
 #endif //!FEATURE_CORECLR
 
             // Determine the startupmode
-            if(g_fEEIJWStartup)
+            if (g_fEEIJWStartup)
             {
                 //IJW Mode
                 startupMode = ETW::InfoLog::InfoStructs::IJW;
             }
-            else if(g_fEEManagedEXEStartup)
+            else if (g_fEEManagedEXEStartup)
             {
                 //managed exe
                 startupMode = ETW::InfoLog::InfoStructs::ManagedExe;
@@ -4083,7 +4091,7 @@ void ETW::InfoLog::RuntimeInformation(INT32 type)
                 lpwszCommandLine = WszGetCommandLine();
 #else
                 INT32 nSize = WideCharToMultiByte(WszGetCommandLine(), szDtraceOutput1);
-                if(nSize > 0) {
+                if (nSize > 0) {
                     lpwszCommandLine = (SIZE_T)szDtraceOutput1;
                 }
 #endif //!FEATURE_DTRACE
@@ -4093,34 +4101,34 @@ void ETW::InfoLog::RuntimeInformation(INT32 type)
                 //Hosted CLR
                 startupMode = ETW::InfoLog::InfoStructs::HostedCLR;
             }
-            else if(g_fEEComActivatedStartup)
+            else if (g_fEEComActivatedStartup)
             {
                 //com activated
                 startupMode = ETW::InfoLog::InfoStructs::COMActivated;
             }
-            else if(g_fEEOtherStartup)
+            else if (g_fEEOtherStartup)
             {
                 //startup type is other
                 startupMode = ETW::InfoLog::InfoStructs::Other;
             }
 
-            _ASSERTE (NumItems(dllPath) > MAX_PATH);
+            _ASSERTE(NumItems(dllPath) > MAX_PATH);
             // if WszGetModuleFileName fails, we return an empty string
             if (!WszGetModuleFileName(GetCLRModule(), dllPath, MAX_PATH)) {
                 dllPath[0] = 0;
             }
             dllPath[MAX_PATH] = 0;
 #ifdef FEATURE_DTRACE
-            _ASSERTE (NumItems(szDtraceOutput2) >= NumItems(dllPath));
+            _ASSERTE(NumItems(szDtraceOutput2) >= NumItems(dllPath));
             INT32 nSize = WideCharToMultiByte(dllPath, szDtraceOutput2);
-            if(nSize > 0) {
+            if (nSize > 0) {
                 lpwszRuntimeDllPath = (SIZE_T)szDtraceOutput2;
             }
 #endif // FEATURE_DTRACE
 
-            if(type == ETW::InfoLog::InfoStructs::Callback)
+            if (type == ETW::InfoLog::InfoStructs::Callback)
             {
-                FireEtwRuntimeInformationDCStart( GetClrInstanceId(),
+                FireEtwRuntimeInformationDCStart(GetClrInstanceId(),
                                                   Sku,
                                                   bclMajorVersion,
                                                   bclMinorVersion,
@@ -4134,11 +4142,11 @@ void ETW::InfoLog::RuntimeInformation(INT32 type)
                                                   startupMode,
                                                   lpwszCommandLine,
                                                   comGUID,
-                                                  lpwszRuntimeDllPath );
+                                                  lpwszRuntimeDllPath);
             }
             else
             {
-                FireEtwRuntimeInformationStart( GetClrInstanceId(),
+                FireEtwRuntimeInformationStart(GetClrInstanceId(),
                                                 Sku,
                                                 bclMajorVersion,
                                                 bclMinorVersion,
@@ -4152,32 +4160,32 @@ void ETW::InfoLog::RuntimeInformation(INT32 type)
                                                 startupMode,
                                                 lpwszCommandLine,
                                                 comGUID,
-                                                lpwszRuntimeDllPath );
+                                                lpwszRuntimeDllPath);
             }
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /*******************************************************/
 /* This is called by the runtime when a method is jitted completely */
 /*******************************************************/
-void ETW::MethodLog::MethodJitted(MethodDesc *pMethodDesc, SString *namespaceOrClassName, SString *methodName, SString *methodSignature, SIZE_T pCode, ReJITID rejitID)
+void ETW::MethodLog::MethodJitted(MethodDesc* pMethodDesc, SString* namespaceOrClassName, SString* methodName, SString* methodSignature, SIZE_T pCode, ReJITID rejitID)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         CLR_JIT_KEYWORD))
         {
             ETW::MethodLog::SendMethodEvent(pMethodDesc, ETW::EnumerationLog::EnumerationStructs::JitMethodLoad, TRUE, namespaceOrClassName, methodName, methodSignature, pCode, rejitID);
         }
 #ifndef WINXP_AND_WIN2K3_BUILD_SUPPORT
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         CLR_JITTEDMETHODILTONATIVEMAP_KEYWORD))
         {
@@ -4192,15 +4200,15 @@ void ETW::MethodLog::MethodJitted(MethodDesc *pMethodDesc, SString *namespaceOrC
             ETW::MethodLog::SendMethodILToNativeMapEvent(pMethodDesc, ETW::EnumerationLog::EnumerationStructs::JitMethodILToNativeMap, rejitID);
         }
 #endif // WINXP_AND_WIN2K3_BUILD_SUPPORT
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /*************************************************/
 /* This is called by the runtime when method jitting started */
 /*************************************************/
-void ETW::MethodLog::MethodJitting(MethodDesc *pMethodDesc, SString *namespaceOrClassName, SString *methodName, SString *methodSignature)
+void ETW::MethodLog::MethodJitting(MethodDesc* pMethodDesc, SString* namespaceOrClassName, SString* methodName, SString* methodSignature)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
         PRECONDITION(pMethodDesc != NULL);
@@ -4208,14 +4216,14 @@ void ETW::MethodLog::MethodJitting(MethodDesc *pMethodDesc, SString *namespaceOr
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_VERBOSE,
                                         CLR_JIT_KEYWORD))
         {
             pMethodDesc->GetMethodInfo(*namespaceOrClassName, *methodName, *methodSignature);
             ETW::MethodLog::SendMethodJitStartEvent(pMethodDesc, namespaceOrClassName, methodName, methodSignature);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /**********************************************************************/
@@ -4223,7 +4231,7 @@ void ETW::MethodLog::MethodJitting(MethodDesc *pMethodDesc, SString *namespaceOr
 /**********************************************************************/
 void ETW::MethodLog::StubInitialized(ULONGLONG ullHelperStartAddress, LPCWSTR pHelperName)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
         PRECONDITION(ullHelperStartAddress != 0);
@@ -4231,31 +4239,31 @@ void ETW::MethodLog::StubInitialized(ULONGLONG ullHelperStartAddress, LPCWSTR pH
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         CLR_JIT_KEYWORD))
         {
-            DWORD dwHelperSize=0;
+            DWORD dwHelperSize = 0;
             Stub::RecoverStubAndSize((TADDR)ullHelperStartAddress, &dwHelperSize);
             ETW::MethodLog::SendHelperEvent(ullHelperStartAddress, dwHelperSize, pHelperName);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /**********************************************************/
 /* This is called by the runtime when helpers with stubs are initialized */
 /**********************************************************/
-void ETW::MethodLog::StubsInitialized(PVOID *pHelperStartAddresss, PVOID *pHelperNames, LONG lNoOfHelpers)
+void ETW::MethodLog::StubsInitialized(PVOID* pHelperStartAddresss, PVOID* pHelperNames, LONG lNoOfHelpers)
 {
     WRAPPER_NO_CONTRACT;
 
-    if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
-                                    TRACE_LEVEL_INFORMATION,
-                                    CLR_JIT_KEYWORD))
+    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        TRACE_LEVEL_INFORMATION,
+        CLR_JIT_KEYWORD))
     {
-        for(int i=0; i<lNoOfHelpers; i++)
+        for (int i = 0; i < lNoOfHelpers; i++)
         {
-            if(pHelperStartAddresss[i])
+            if (pHelperStartAddresss[i])
             {
                 StubInitialized((ULONGLONG)pHelperStartAddresss[i], (LPCWSTR)pHelperNames[i]);
             }
@@ -4266,35 +4274,35 @@ void ETW::MethodLog::StubsInitialized(PVOID *pHelperStartAddresss, PVOID *pHelpe
 /****************************************************************************/
 /* This is called by the runtime when a dynamic method is destroyed */
 /****************************************************************************/
-void ETW::MethodLog::DynamicMethodDestroyed(MethodDesc *pMethodDesc)
+void ETW::MethodLog::DynamicMethodDestroyed(MethodDesc* pMethodDesc)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         CLR_JIT_KEYWORD))
             ETW::MethodLog::SendMethodEvent(pMethodDesc, ETW::EnumerationLog::EnumerationStructs::JitMethodUnload, TRUE);
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
 /* This is called by the runtime when a ngen method is restored */
 /****************************************************************************/
-void ETW::MethodLog::MethodRestored(MethodDesc *pMethodDesc)
+void ETW::MethodLog::MethodRestored(MethodDesc* pMethodDesc)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
     EX_TRY
     {
-        if(IsRuntimeNgenKeywordEnabledAndNotSuppressed()
+        if (IsRuntimeNgenKeywordEnabledAndNotSuppressed()
            &&
            ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
@@ -4302,40 +4310,40 @@ void ETW::MethodLog::MethodRestored(MethodDesc *pMethodDesc)
         {
             ETW::MethodLog::SendMethodEvent(pMethodDesc, ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad, FALSE);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
 /* This is called by the runtime when a method table is restored */
 /****************************************************************************/
-void ETW::MethodLog::MethodTableRestored(MethodTable *pMethodTable)
+void ETW::MethodLog::MethodTableRestored(MethodTable* pMethodTable)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
     EX_TRY
     {
-        if(IsRuntimeNgenKeywordEnabledAndNotSuppressed()
+        if (IsRuntimeNgenKeywordEnabledAndNotSuppressed()
             &&
             ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                          TRACE_LEVEL_INFORMATION,
                                          CLR_STARTENUMERATION_KEYWORD))
         {
 #ifdef FEATURE_REMOTING
-            if(!pMethodTable->IsThunking())
+            if (!pMethodTable->IsThunking())
 #endif
             {
                 MethodTable::MethodIterator iter(pMethodTable);
                 for (; iter.IsValid(); iter.Next())
                 {
-                    MethodDesc *pMD = (MethodDesc *)(iter.GetMethodDesc());
-                    if(pMD && pMD->IsRestored() && pMD->GetMethodTable_NoLogging() == pMethodTable)
+                    MethodDesc* pMD = (MethodDesc*)(iter.GetMethodDesc());
+                    if (pMD && pMD->IsRestored() && pMD->GetMethodTable_NoLogging() == pMethodTable)
                         ETW::MethodLog::SendMethodEvent(pMD, ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad, FALSE);
                 }
             }
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 
@@ -4362,7 +4370,7 @@ void ETW::SecurityLog::StrongNameVerificationStart(DWORD dwInFlags, _In_ LPWSTR
 /****************************************************************************/
 /* This is called by the runtime when a Strong Name Verification Ends */
 /****************************************************************************/
-void ETW::SecurityLog::StrongNameVerificationStop(DWORD dwInFlags,ULONG result, _In_ LPWSTR strFullyQualifiedAssemblyName)
+void ETW::SecurityLog::StrongNameVerificationStop(DWORD dwInFlags, ULONG result, _In_ LPWSTR strFullyQualifiedAssemblyName)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_CORECLR
@@ -4382,8 +4390,8 @@ void ETW::SecurityLog::StrongNameVerificationStop(DWORD dwInFlags,ULONG result,
 /* This is called by the runtime when field transparency calculations begin */
 /****************************************************************************/
 void ETW::SecurityLog::FireFieldTransparencyComputationStart(LPCWSTR wszFieldName,
-                                                             LPCWSTR wszModuleName,
-                                                             DWORD dwAppDomain)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4404,10 +4412,10 @@ void ETW::SecurityLog::FireFieldTransparencyComputationStart(LPCWSTR wszFieldNam
 /* This is called by the runtime when field transparency calculations end   */
 /****************************************************************************/
 void ETW::SecurityLog::FireFieldTransparencyComputationEnd(LPCWSTR wszFieldName,
-                                                           LPCWSTR wszModuleName,
-                                                           DWORD dwAppDomain,
-                                                           BOOL fIsCritical,
-                                                           BOOL fIsTreatAsSafe)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain,
+    BOOL fIsCritical,
+    BOOL fIsTreatAsSafe)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4428,8 +4436,8 @@ void ETW::SecurityLog::FireFieldTransparencyComputationEnd(LPCWSTR wszFieldName,
 /* This is called by the runtime when method transparency calculations begin */
 /*****************************************************************************/
 void ETW::SecurityLog::FireMethodTransparencyComputationStart(LPCWSTR wszMethodName,
-                                                              LPCWSTR wszModuleName,
-                                                              DWORD dwAppDomain)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4450,10 +4458,10 @@ void ETW::SecurityLog::FireMethodTransparencyComputationStart(LPCWSTR wszMethodN
 /* This is called by the runtime when method transparency calculations end   */
 /********************************************(********************************/
 void ETW::SecurityLog::FireMethodTransparencyComputationEnd(LPCWSTR wszMethodName,
-                                                            LPCWSTR wszModuleName,
-                                                            DWORD dwAppDomain,
-                                                            BOOL fIsCritical,
-                                                            BOOL fIsTreatAsSafe)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain,
+    BOOL fIsCritical,
+    BOOL fIsTreatAsSafe)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4474,7 +4482,7 @@ void ETW::SecurityLog::FireMethodTransparencyComputationEnd(LPCWSTR wszMethodNam
 /* This is called by the runtime when module transparency calculations begin */
 /*****************************************************************************/
 void ETW::SecurityLog::FireModuleTransparencyComputationStart(LPCWSTR wszModuleName,
-                                                              DWORD dwAppDomain)
+    DWORD dwAppDomain)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4493,12 +4501,12 @@ void ETW::SecurityLog::FireModuleTransparencyComputationStart(LPCWSTR wszModuleN
 /* This is called by the runtime when module transparency calculations end  */
 /****************************************************************************/
 void ETW::SecurityLog::FireModuleTransparencyComputationEnd(LPCWSTR wszModuleName,
-                                                            DWORD dwAppDomain,
-                                                            BOOL fIsAllCritical,
-                                                            BOOL fIsAllTransparent,
-                                                            BOOL fIsTreatAsSafe,
-                                                            BOOL fIsOpportunisticallyCritical,
-                                                            DWORD dwSecurityRuleSet)
+    DWORD dwAppDomain,
+    BOOL fIsAllCritical,
+    BOOL fIsAllTransparent,
+    BOOL fIsTreatAsSafe,
+    BOOL fIsOpportunisticallyCritical,
+    DWORD dwSecurityRuleSet)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4517,8 +4525,8 @@ void ETW::SecurityLog::FireModuleTransparencyComputationEnd(LPCWSTR wszModuleNam
 /* This is called by the runtime when token transparency calculations begin */
 /****************************************************************************/
 void ETW::SecurityLog::FireTokenTransparencyComputationStart(DWORD dwToken,
-                                                             LPCWSTR wszModuleName,
-                                                             DWORD dwAppDomain)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4537,10 +4545,10 @@ void ETW::SecurityLog::FireTokenTransparencyComputationStart(DWORD dwToken,
 /* This is called by the runtime when token transparency calculations end   */
 /****************************************************************************/
 void ETW::SecurityLog::FireTokenTransparencyComputationEnd(DWORD dwToken,
-                                                           LPCWSTR wszModuleName,
-                                                           DWORD dwAppDomain,
-                                                           BOOL fIsCritical,
-                                                           BOOL fIsTreatAsSafe)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain,
+    BOOL fIsCritical,
+    BOOL fIsTreatAsSafe)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4559,8 +4567,8 @@ void ETW::SecurityLog::FireTokenTransparencyComputationEnd(DWORD dwToken,
 /* This is called by the runtime when type transparency calculations begin   */
 /*****************************************************************************/
 void ETW::SecurityLog::FireTypeTransparencyComputationStart(LPCWSTR wszTypeName,
-                                                            LPCWSTR wszModuleName,
-                                                            DWORD dwAppDomain)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4581,12 +4589,12 @@ void ETW::SecurityLog::FireTypeTransparencyComputationStart(LPCWSTR wszTypeName,
 /* This is called by the runtime when type transparency calculations end    */
 /****************************************************************************/
 void ETW::SecurityLog::FireTypeTransparencyComputationEnd(LPCWSTR wszTypeName,
-                                                          LPCWSTR wszModuleName,
-                                                          DWORD dwAppDomain,
-                                                          BOOL fIsAllCritical,
-                                                          BOOL fIsAllTransparent,
-                                                          BOOL fIsCritical,
-                                                          BOOL fIsTreatAsSafe)
+    LPCWSTR wszModuleName,
+    DWORD dwAppDomain,
+    BOOL fIsAllCritical,
+    BOOL fIsAllTransparent,
+    BOOL fIsCritical,
+    BOOL fIsTreatAsSafe)
 {
     WRAPPER_NO_CONTRACT;
 #ifndef FEATURE_DTRACE
@@ -4607,9 +4615,9 @@ void ETW::SecurityLog::FireTypeTransparencyComputationEnd(LPCWSTR wszTypeName,
 /* This is called by the runtime when a module is loaded */
 /* liReportedSharedModule will be 0 when this module is reported for the 1st time */
 /**********************************************************************************/
-void ETW::LoaderLog::ModuleLoad(Module *pModule, LONG liReportedSharedModule)
+void ETW::LoaderLog::ModuleLoad(Module* pModule, LONG liReportedSharedModule)
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
@@ -4617,7 +4625,7 @@ void ETW::LoaderLog::ModuleLoad(Module *pModule, LONG liReportedSharedModule)
     EX_TRY
     {
         DWORD enumerationOptions = ETW::EnumerationLog::EnumerationStructs::None;
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
                                         TRACE_LEVEL_INFORMATION,
                                         KEYWORDZERO))
         {
@@ -4632,27 +4640,27 @@ void ETW::LoaderLog::ModuleLoad(Module *pModule, LONG liReportedSharedModule)
                                                                           TRACE_LEVEL_INFORMATION,
                                                                           CLR_PERFTRACK_KEYWORD);
 
-            if(liReportedSharedModule == 0)
+            if (liReportedSharedModule == 0)
             {
 
-                if(bTraceFlagLoaderSet)
+                if (bTraceFlagLoaderSet)
                     enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad;
                 if (bTraceFlagPerfTrackSet)
                     enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoad;
-                if(bTraceFlagNgenMethodSet && bTraceFlagStartRundownSet)
+                if (bTraceFlagNgenMethodSet && bTraceFlagStartRundownSet)
                     enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad;
 
-                if(pModule->IsManifest() && bTraceFlagLoaderSet)
+                if (pModule->IsManifest() && bTraceFlagLoaderSet)
                     ETW::LoaderLog::SendAssemblyEvent(pModule->GetAssembly(), enumerationOptions);
 
-                if(bTraceFlagLoaderSet || bTraceFlagPerfTrackSet)
+                if (bTraceFlagLoaderSet || bTraceFlagPerfTrackSet)
                     ETW::LoaderLog::SendModuleEvent(pModule, ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad | ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoad);
 
                 ETW::EnumerationLog::EnumerationHelper(pModule, NULL, enumerationOptions);
             }
 
             // we want to report domainmodule events whenever they are loaded in any AppDomain
-            if(bTraceFlagLoaderSet)
+            if (bTraceFlagLoaderSet)
                 ETW::LoaderLog::SendModuleEvent(pModule, ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad, TRUE);
         }
 
@@ -4668,7 +4676,7 @@ void ETW::LoaderLog::ModuleLoad(Module *pModule, LONG liReportedSharedModule)
             }
         }
 #endif
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
@@ -4676,14 +4684,14 @@ void ETW::LoaderLog::ModuleLoad(Module *pModule, LONG liReportedSharedModule)
 /****************************************************************************/
 void ETW::EnumerationLog::ProcessShutdown()
 {
-    CONTRACTL {
+    CONTRACTL{
         NOTHROW;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
     EX_TRY
     {
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, TRACE_LEVEL_INFORMATION, KEYWORDZERO))
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context, TRACE_LEVEL_INFORMATION, KEYWORDZERO))
         {
             DWORD enumerationOptions = GetEnumerationOptionsFromRuntimeKeywords();
 
@@ -4691,7 +4699,7 @@ void ETW::EnumerationLog::ProcessShutdown()
             // default domain.
             ETW::EnumerationLog::EnumerationHelper(NULL /* module filter */, NULL /* domain filter */, enumerationOptions);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /****************************************************************************/
@@ -4703,18 +4711,18 @@ void ETW::EnumerationLog::ProcessShutdown()
 /****************************************************************************/
 /* This routine is used to send a domain load/unload or rundown event                              */
 /****************************************************************************/
-void ETW::LoaderLog::SendDomainEvent(BaseDomain *pBaseDomain, DWORD dwEventOptions, LPCWSTR wszFriendlyName)
+void ETW::LoaderLog::SendDomainEvent(BaseDomain* pBaseDomain, DWORD dwEventOptions, LPCWSTR wszFriendlyName)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
-    if(!pBaseDomain)
+    if (!pBaseDomain)
         return;
 
 #ifndef FEATURE_DTRACE
-    PCWSTR szDtraceOutput1=L"";
+    PCWSTR szDtraceOutput1 = L"";
 #else
     CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
 #endif // !FEATURE_DTRACE
@@ -4722,22 +4730,22 @@ void ETW::LoaderLog::SendDomainEvent(BaseDomain *pBaseDomain, DWORD dwEventOptio
     BOOL bIsAppDomain = pBaseDomain->IsAppDomain();
     BOOL bIsExecutable = bIsAppDomain ? !(pBaseDomain->AsAppDomain()->IsPassiveDomain()) : FALSE;
     BOOL bIsSharedDomain = pBaseDomain->IsSharedDomain();
-    UINT32 uSharingPolicy = bIsAppDomain?(pBaseDomain->AsAppDomain()->GetSharePolicy()):0;
+    UINT32 uSharingPolicy = bIsAppDomain ? (pBaseDomain->AsAppDomain()->GetSharePolicy()) : 0;
 
     ULONGLONG ullDomainId = (ULONGLONG)pBaseDomain;
     ULONG ulDomainFlags = ((bIsDefaultDomain ? ETW::LoaderLog::LoaderStructs::DefaultDomain : 0) |
-                           (bIsExecutable ? ETW::LoaderLog::LoaderStructs::ExecutableDomain : 0) |
-                           (bIsSharedDomain ? ETW::LoaderLog::LoaderStructs::SharedDomain : 0) |
-                           (uSharingPolicy<<28));
+        (bIsExecutable ? ETW::LoaderLog::LoaderStructs::ExecutableDomain : 0) |
+        (bIsSharedDomain ? ETW::LoaderLog::LoaderStructs::SharedDomain : 0) |
+        (uSharingPolicy << 28));
 
     LPCWSTR wsEmptyString = L"";
     LPCWSTR wsSharedString = L"SharedDomain";
 
     LPWSTR lpswzDomainName = (LPWSTR)wsEmptyString;
 
-    if(bIsAppDomain)
+    if (bIsAppDomain)
     {
-        if(wszFriendlyName)
+        if (wszFriendlyName)
             lpswzDomainName = (PWCHAR)wszFriendlyName;
         else
             lpswzDomainName = (PWCHAR)pBaseDomain->AsAppDomain()->GetFriendlyName();
@@ -4755,28 +4763,28 @@ void ETW::LoaderLog::SendDomainEvent(BaseDomain *pBaseDomain, DWORD dwEventOptio
         return;
 #endif // !FEATURE_DTRACE
 
-    if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad)
+    if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad)
     {
         FireEtwAppDomainLoad_V1(ullDomainId, ulDomainFlags, szDtraceOutput1, pBaseDomain->GetId().m_dwId, GetClrInstanceId());
     }
-    else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)
+    else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)
     {
         FireEtwAppDomainUnload_V1(ullDomainId, ulDomainFlags, szDtraceOutput1, pBaseDomain->GetId().m_dwId, GetClrInstanceId());
     }
-    else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
+    else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
     {
         FireEtwAppDomainDCStart_V1(ullDomainId, ulDomainFlags, szDtraceOutput1, pBaseDomain->GetId().m_dwId, GetClrInstanceId());
     }
-    else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd)
+    else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd)
     {
         FireEtwAppDomainDCEnd_V1(ullDomainId, ulDomainFlags, szDtraceOutput1, pBaseDomain->GetId().m_dwId, GetClrInstanceId());
     }
     else
     {
         _ASSERTE((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad) ||
-                 (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
-                 (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
-                 (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd));
+            (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
+            (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
+            (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd));
     }
 }
 
@@ -4785,13 +4793,13 @@ void ETW::LoaderLog::SendDomainEvent(BaseDomain *pBaseDomain, DWORD dwEventOptio
 /********************************************************/
 void ETW::EnumerationLog::SendThreadRundownEvent()
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
 #ifndef DACCESS_COMPILE
-    Thread *pThread = NULL;
+    Thread* pThread = NULL;
 
     // Take the thread store lock while we enumerate threads.
     ThreadStoreLockHolder tsl;
@@ -4811,24 +4819,24 @@ void ETW::EnumerationLog::SendThreadRundownEvent()
 /****************************************************************************/
 /* This routine is used to send an assembly load/unload or rundown event ****/
 /****************************************************************************/
-void ETW::LoaderLog::SendAssemblyEvent(Assembly *pAssembly, DWORD dwEventOptions)
+void ETW::LoaderLog::SendAssemblyEvent(Assembly* pAssembly, DWORD dwEventOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
-    if(!pAssembly)
+    if (!pAssembly)
         return;
 
 #ifndef FEATURE_DTRACE
-    PCWSTR szDtraceOutput1=L"";
+    PCWSTR szDtraceOutput1 = L"";
 #else
     CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
 #endif // !FEATURE_DTRACE
     BOOL bIsDynamicAssembly = pAssembly->IsDynamic();
     BOOL bIsCollectibleAssembly = pAssembly->IsCollectible();
-    BOOL bIsDomainNeutral = pAssembly->IsDomainNeutral() ;
+    BOOL bIsDomainNeutral = pAssembly->IsDomainNeutral();
     BOOL bHasNativeImage = pAssembly->GetManifestFile()->HasNativeImage();
 
     ULONGLONG ullAssemblyId = (ULONGLONG)pAssembly;
@@ -4838,15 +4846,15 @@ void ETW::LoaderLog::SendAssemblyEvent(Assembly *pAssembly, DWORD dwEventOptions
     ullBindingID = pAssembly->GetManifestFile()->GetBindingID();
 #endif
     ULONG ulAssemblyFlags = ((bIsDomainNeutral ? ETW::LoaderLog::LoaderStructs::DomainNeutralAssembly : 0) |
-                             (bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicAssembly : 0) |
-                             (bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeAssembly : 0) |
-                             (bIsCollectibleAssembly ? ETW::LoaderLog::LoaderStructs::CollectibleAssembly : 0));
+        (bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicAssembly : 0) |
+        (bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeAssembly : 0) |
+        (bIsCollectibleAssembly ? ETW::LoaderLog::LoaderStructs::CollectibleAssembly : 0));
 
     SString sAssemblyPath;
     pAssembly->GetDisplayName(sAssemblyPath);
     LPWSTR lpszAssemblyPath = (LPWSTR)sAssemblyPath.GetUnicode();
 
-/* prepare events args for ETW and ETM */
+    /* prepare events args for ETW and ETM */
 #ifndef FEATURE_DTRACE
     szDtraceOutput1 = (PCWSTR)lpszAssemblyPath;
 #else // !FEATURE_DTRACE
@@ -4856,36 +4864,36 @@ void ETW::LoaderLog::SendAssemblyEvent(Assembly *pAssembly, DWORD dwEventOptions
         return;
 #endif // !FEATURE_DTRACE
 
-    if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad)
+    if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad)
     {
         FireEtwAssemblyLoad_V1(ullAssemblyId, ullDomainId, ullBindingID, ulAssemblyFlags, szDtraceOutput1, GetClrInstanceId());
     }
-    else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)
+    else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)
     {
         FireEtwAssemblyUnload_V1(ullAssemblyId, ullDomainId, ullBindingID, ulAssemblyFlags, szDtraceOutput1, GetClrInstanceId());
     }
-    else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
+    else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
     {
         FireEtwAssemblyDCStart_V1(ullAssemblyId, ullDomainId, ullBindingID, ulAssemblyFlags, szDtraceOutput1, GetClrInstanceId());
     }
-    else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd)
+    else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd)
     {
         FireEtwAssemblyDCEnd_V1(ullAssemblyId, ullDomainId, ullBindingID, ulAssemblyFlags, szDtraceOutput1, GetClrInstanceId());
     }
     else
     {
         _ASSERTE((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad) ||
-                 (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
-                 (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
-                 (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd));
+            (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
+            (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
+            (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd));
     }
 }
 
 #if !defined(FEATURE_PAL)
 ETW_INLINE
-    ULONG
-    ETW::LoaderLog::SendModuleRange(
-    _In_ Module *pModule,
+ULONG
+ETW::LoaderLog::SendModuleRange(
+    _In_ Module* pModule,
     _In_ DWORD dwEventOptions)
 
 {
@@ -4895,22 +4903,22 @@ ETW_INLINE
     // do not fire the ETW event when:
     // 1. We did not load the native image
     // 2. We do not have IBC data for the native image
-    if( !pModule || !pModule->HasNativeImage() || !pModule->IsIbcOptimized() )
+    if (!pModule || !pModule->HasNativeImage() || !pModule->IsIbcOptimized())
     {
         return Result;
     }
 
     // get information about the hot sections from the native image that has been loaded
     COUNT_T cbSizeOfSectionTable;
-    CORCOMPILE_VIRTUAL_SECTION_INFO* pVirtualSectionsTable = (CORCOMPILE_VIRTUAL_SECTION_INFO* )pModule->GetNativeImage()->GetVirtualSectionsTable(&cbSizeOfSectionTable);
+    CORCOMPILE_VIRTUAL_SECTION_INFO* pVirtualSectionsTable = (CORCOMPILE_VIRTUAL_SECTION_INFO*)pModule->GetNativeImage()->GetVirtualSectionsTable(&cbSizeOfSectionTable);
 
-    COUNT_T RangeCount = cbSizeOfSectionTable/sizeof(CORCOMPILE_VIRTUAL_SECTION_INFO);
+    COUNT_T RangeCount = cbSizeOfSectionTable / sizeof(CORCOMPILE_VIRTUAL_SECTION_INFO);
 
     // if we do not have any hot ranges, we do not fire the ETW event
 
     // Figure out the rest of the event data
     UINT16 ClrInstanceId = GetClrInstanceId();
-    UINT64 ModuleID = (ULONGLONG)(TADDR) pModule;
+    UINT64 ModuleID = (ULONGLONG)(TADDR)pModule;
 
     for (COUNT_T i = 0; i < RangeCount; ++i)
     {
@@ -4972,13 +4980,13 @@ ETW_INLINE
 //         untrusted, and reported sizes of buffers are verified against their data.
 //
 
-static void GetCodeViewInfo(Module * pModule, CV_INFO_PDB70 * pCvInfoIL, CV_INFO_PDB70 * pCvInfoNative)
+static void GetCodeViewInfo(Module* pModule, CV_INFO_PDB70* pCvInfoIL, CV_INFO_PDB70* pCvInfoNative)
 {
     LIMITED_METHOD_CONTRACT;
 
-    _ASSERTE (pModule != NULL);
-    _ASSERTE (pCvInfoIL != NULL);
-    _ASSERTE (pCvInfoNative != NULL);
+    _ASSERTE(pModule != NULL);
+    _ASSERTE(pCvInfoIL != NULL);
+    _ASSERTE(pCvInfoNative != NULL);
 
     ZeroMemory(pCvInfoIL, sizeof(*pCvInfoIL));
     ZeroMemory(pCvInfoNative, sizeof(*pCvInfoNative));
@@ -5013,8 +5021,8 @@ static void GetCodeViewInfo(Module * pModule, CV_INFO_PDB70 * pCvInfoIL, CV_INFO
         return;
 
     COUNT_T cbDebugEntries;
-    IMAGE_DEBUG_DIRECTORY * rgDebugEntries =
-        (IMAGE_DEBUG_DIRECTORY *) pLayout->GetDirectoryEntryData(IMAGE_DIRECTORY_ENTRY_DEBUG, &cbDebugEntries);
+    IMAGE_DEBUG_DIRECTORY* rgDebugEntries =
+        (IMAGE_DEBUG_DIRECTORY*)pLayout->GetDirectoryEntryData(IMAGE_DIRECTORY_ENTRY_DEBUG, &cbDebugEntries);
 
     if (cbDebugEntries < sizeof(IMAGE_DEBUG_DIRECTORY))
         return;
@@ -5028,15 +5036,15 @@ static void GetCodeViewInfo(Module * pModule, CV_INFO_PDB70 * pCvInfoIL, CV_INFO
     // sizeof(CV_INFO_PDB70); see below).
     struct PdbInfo
     {
-        CV_INFO_PDB70 *     m_pPdb70;
+        CV_INFO_PDB70* m_pPdb70;
         ULONG               m_cbPdb70;
     };
 
     // Iterate through all debug directory entries.  The very last one will be the
     // managed PDB entry.  The next to last one (if it exists) will be the (native) NGEN
     // PDB entry.  Treat raw bytes we read as untrusted.
-    PdbInfo pdbInfoLast = {0};
-    PdbInfo pdbInfoNextToLast = {0};
+    PdbInfo pdbInfoLast = { 0 };
+    PdbInfo pdbInfoNextToLast = { 0 };
     int cEntries = cbDebugEntries / sizeof(IMAGE_DEBUG_DIRECTORY);
     for (int i = 0; i < cEntries; i++)
     {
@@ -5068,7 +5076,7 @@ static void GetCodeViewInfo(Module * pModule, CV_INFO_PDB70 * pCvInfoIL, CV_INFO
         }
 
         // Verify the magic number is as expected
-        CV_INFO_PDB70 * pPdb70 = (CV_INFO_PDB70 *) pLayout->GetRvaData(rvaOfRawData);
+        CV_INFO_PDB70* pPdb70 = (CV_INFO_PDB70*)pLayout->GetRvaData(rvaOfRawData);
         if (pPdb70->magic != CV_SIGNATURE_RSDS)
         {
             // Unrecognized magic number.  Skip
@@ -5143,18 +5151,18 @@ static void GetCodeViewInfo(Module * pModule, CV_INFO_PDB70 * pCvInfoIL, CV_INFO
 //      * bFireDomainModuleEvents - nonzero if we are to fire DomainModule events; zero
 //          if we are to fire Module events
 //
-void ETW::LoaderLog::SendModuleEvent(Module *pModule, DWORD dwEventOptions, BOOL bFireDomainModuleEvents)
+void ETW::LoaderLog::SendModuleEvent(Module* pModule, DWORD dwEventOptions, BOOL bFireDomainModuleEvents)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
-    if(!pModule)
+    if (!pModule)
         return;
 
 #ifndef FEATURE_DTRACE
-    PCWSTR szDtraceOutput1=L"",szDtraceOutput2=L"";
+    PCWSTR szDtraceOutput1 = L"", szDtraceOutput2 = L"";
 #else
     CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
     CHAR szDtraceOutput2[DTRACE_OUTPUT_STRING_LEN];
@@ -5166,35 +5174,35 @@ void ETW::LoaderLog::SendModuleEvent(Module *pModule, DWORD dwEventOptions, BOOL
 #endif // FEATURE_PREJIT
     BOOL bIsManifestModule = pModule->IsManifest();
     ULONGLONG ullAppDomainId = 0; // This is used only with DomainModule events
-    ULONGLONG ullModuleId = (ULONGLONG)(TADDR) pModule;
+    ULONGLONG ullModuleId = (ULONGLONG)(TADDR)pModule;
     ULONGLONG ullAssemblyId = (ULONGLONG)pModule->GetAssembly();
     BOOL bIsDomainNeutral = pModule->GetAssembly()->IsDomainNeutral();
     BOOL bIsIbcOptimized = FALSE;
-    if(bHasNativeImage)
+    if (bHasNativeImage)
     {
         bIsIbcOptimized = pModule->IsIbcOptimized();
     }
     ULONG ulReservedFlags = 0;
     ULONG ulFlags = ((bIsDomainNeutral ? ETW::LoaderLog::LoaderStructs::DomainNeutralModule : 0) |
-                     (bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeModule : 0) |
-                     (bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicModule : 0) |
-                     (bIsManifestModule ? ETW::LoaderLog::LoaderStructs::ManifestModule : 0) |
-                     (bIsIbcOptimized ? ETW::LoaderLog::LoaderStructs::IbcOptimized : 0));
+        (bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeModule : 0) |
+        (bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicModule : 0) |
+        (bIsManifestModule ? ETW::LoaderLog::LoaderStructs::ManifestModule : 0) |
+        (bIsIbcOptimized ? ETW::LoaderLog::LoaderStructs::IbcOptimized : 0));
 
 #ifndef FEATURE_DTRACE
     // Grab PDB path, guid, and age for managed PDB and native (NGEN) PDB when
     // available.  Any failures are not fatal.  The corresponding PDB info will remain
     // zeroed out, and that's what we'll include in the event.
-    CV_INFO_PDB70 cvInfoIL = {0};
-    CV_INFO_PDB70 cvInfoNative = {0};
+    CV_INFO_PDB70 cvInfoIL = { 0 };
+    CV_INFO_PDB70 cvInfoNative = { 0 };
     GetCodeViewInfo(pModule, &cvInfoIL, &cvInfoNative);
 #endif // FEATURE_DTRACE
 
-    PWCHAR ModuleILPath=L"", ModuleNativePath=L"";
+    PWCHAR ModuleILPath = L"", ModuleNativePath = L"";
 
-    if(bFireDomainModuleEvents)
+    if (bFireDomainModuleEvents)
     {
-        if(pModule->GetDomain()->IsSharedDomain()) // for shared domains, we do not fire domainmodule event
+        if (pModule->GetDomain()->IsSharedDomain()) // for shared domains, we do not fire domainmodule event
             return;
         ullAppDomainId = (ULONGLONG)pModule->FindDomainAssembly(pModule->GetDomain()->AsAppDomain())->GetAppDomain();
     }
@@ -5205,19 +5213,19 @@ void ETW::LoaderLog::SendModuleEvent(Module *pModule, DWORD dwEventOptions, BOOL
 #else // !FEATURE_PAL
     SString moduleName;
 #endif // !FEATURE_PAL
-    if(!bIsDynamicAssembly)
+    if (!bIsDynamicAssembly)
     {
         ModuleILPath = (PWCHAR)pModule->GetAssembly()->GetManifestFile()->GetILimage()->GetPath().GetUnicode();
         ModuleNativePath = (PWCHAR)pEmptyString;
 
 #ifdef FEATURE_PREJIT
-        if(bHasNativeImage)
+        if (bHasNativeImage)
             ModuleNativePath = (PWCHAR)pModule->GetNativeImage()->GetPath().GetUnicode();
 #endif // FEATURE_PREJIT
     }
 
     // if we do not have a module path yet, we put the module name
-    if(bIsDynamicAssembly || ModuleILPath==NULL || wcslen(ModuleILPath) <= 2)
+    if (bIsDynamicAssembly || ModuleILPath == NULL || wcslen(ModuleILPath) <= 2)
     {
         moduleName.SetUTF8(pModule->GetSimpleName());
         ModuleILPath = (PWCHAR)moduleName.GetUnicode();
@@ -5242,52 +5250,52 @@ void ETW::LoaderLog::SendModuleEvent(Module *pModule, DWORD dwEventOptions, BOOL
         return;
 #endif // !FEATURE_DTRACE
 
-    if(bFireDomainModuleEvents)
+    if (bFireDomainModuleEvents)
     {
-        if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad)
+        if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad)
         {
             FireEtwDomainModuleLoad_V1(ullModuleId, ullAssemblyId, ullAppDomainId, ulFlags, ulReservedFlags, szDtraceOutput1, szDtraceOutput2, GetClrInstanceId());
         }
-        else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
+        else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
         {
             FireEtwDomainModuleDCStart_V1(ullModuleId, ullAssemblyId, ullAppDomainId, ulFlags, ulReservedFlags, szDtraceOutput1, szDtraceOutput2, GetClrInstanceId());
         }
-        else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd)
+        else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd)
         {
             FireEtwDomainModuleDCEnd_V1(ullModuleId, ullAssemblyId, ullAppDomainId, ulFlags, ulReservedFlags, szDtraceOutput1, szDtraceOutput2, GetClrInstanceId());
         }
         else
         {
             _ASSERTE((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad) ||
-                     (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
-                     (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd));
+                (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
+                (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd));
         }
     }
     else
     {
-        if((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad) || (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoad))
+        if ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad) || (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoad))
         {
             FireEtwModuleLoad_V1_or_V2(ullModuleId, ullAssemblyId, ulFlags, ulReservedFlags, szDtraceOutput1, szDtraceOutput2, GetClrInstanceId(), &cvInfoIL.signature, cvInfoIL.age, managedPdbPath, &cvInfoNative.signature, cvInfoNative.age, nativePdbPath);
         }
-        else if(dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)
+        else if (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)
         {
             FireEtwModuleUnload_V1_or_V2(ullModuleId, ullAssemblyId, ulFlags, ulReservedFlags, szDtraceOutput1, szDtraceOutput2, GetClrInstanceId(), &cvInfoIL.signature, cvInfoIL.age, managedPdbPath, &cvInfoNative.signature, cvInfoNative.age, nativePdbPath);
         }
-        else if((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) || (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCStart))
+        else if ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) || (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCStart))
         {
             FireEtwModuleDCStart_V1_or_V2(ullModuleId, ullAssemblyId, ulFlags, ulReservedFlags, szDtraceOutput1, szDtraceOutput2, GetClrInstanceId(), &cvInfoIL.signature, cvInfoIL.age, managedPdbPath, &cvInfoNative.signature, cvInfoNative.age, nativePdbPath);
         }
-        else if((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) || (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCEnd))
+        else if ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) || (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCEnd))
         {
             FireEtwModuleDCEnd_V1_or_V2(ullModuleId, ullAssemblyId, ulFlags, ulReservedFlags, szDtraceOutput1, szDtraceOutput2, GetClrInstanceId(), &cvInfoIL.signature, cvInfoIL.age, managedPdbPath, &cvInfoNative.signature, cvInfoNative.age, nativePdbPath);
         }
         else
         {
             _ASSERTE((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad) ||
-                     (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
-                     (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
-                     (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
-                     (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeEnabledAny));
+                (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
+                (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
+                (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
+                (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeEnabledAny));
 
         }
 #if !defined(FEATURE_PAL)
@@ -5303,55 +5311,55 @@ void ETW::LoaderLog::SendModuleEvent(Module *pModule, DWORD dwEventOptions, BOOL
 /*****************************************************************/
 /* This routine is used to send an ETW event just before a method starts jitting*/
 /*****************************************************************/
-void ETW::MethodLog::SendMethodJitStartEvent(MethodDesc *pMethodDesc, SString *namespaceOrClassName, SString *methodName, SString *methodSignature)
+void ETW::MethodLog::SendMethodJitStartEvent(MethodDesc* pMethodDesc, SString* namespaceOrClassName, SString* methodName, SString* methodSignature)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
-    Module *pModule = NULL;
-    Module *pLoaderModule = NULL; // This must not be used except for getting the ModuleID
+    Module* pModule = NULL;
+    Module* pLoaderModule = NULL; // This must not be used except for getting the ModuleID
 
-    ULONGLONG ullMethodIdentifier=0;
-    ULONGLONG ullModuleID=0;
-    ULONG ulMethodToken=0;
-    ULONG ulMethodILSize=0;
+    ULONGLONG ullMethodIdentifier = 0;
+    ULONGLONG ullModuleID = 0;
+    ULONG ulMethodToken = 0;
+    ULONG ulMethodILSize = 0;
 #ifndef FEATURE_DTRACE
-    PCWSTR szDtraceOutput1=L"",szDtraceOutput2=L"",szDtraceOutput3=L"";
+    PCWSTR szDtraceOutput1 = L"", szDtraceOutput2 = L"", szDtraceOutput3 = L"";
 #else
     CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
     CHAR szDtraceOutput2[DTRACE_OUTPUT_STRING_LEN];
     CHAR szDtraceOutput3[DTRACE_OUTPUT_STRING_LEN];
 #endif // !FEATURE_DTRACE
 
-    if(pMethodDesc) {
+    if (pMethodDesc) {
         pModule = pMethodDesc->GetModule_NoLogging();
 
-        if(!pMethodDesc->IsRestored()) {
-                return;
+        if (!pMethodDesc->IsRestored()) {
+            return;
         }
 
         bool bIsDynamicMethod = pMethodDesc->IsDynamicMethod();
         BOOL bIsGenericMethod = FALSE;
-        if(pMethodDesc->GetMethodTable_NoLogging())
+        if (pMethodDesc->GetMethodTable_NoLogging())
             bIsGenericMethod = pMethodDesc->HasClassOrMethodInstantiation_NoLogging();
 
-        ullModuleID = (ULONGLONG)(TADDR) pModule;
+        ullModuleID = (ULONGLONG)(TADDR)pModule;
         ullMethodIdentifier = (ULONGLONG)pMethodDesc;
 
         // Use MethodDesc if Dynamic or Generic methods
-        if( bIsDynamicMethod || bIsGenericMethod)
+        if (bIsDynamicMethod || bIsGenericMethod)
         {
-            if(bIsGenericMethod)
+            if (bIsGenericMethod)
                 ulMethodToken = (ULONG)pMethodDesc->GetMemberDef_NoLogging();
-            if(bIsDynamicMethod) // if its a generic and a dynamic method, we would set the methodtoken to 0
+            if (bIsDynamicMethod) // if its a generic and a dynamic method, we would set the methodtoken to 0
                 ulMethodToken = (ULONG)0;
         }
         else
             ulMethodToken = (ULONG)pMethodDesc->GetMemberDef_NoLogging();
 
-        if(pMethodDesc->IsIL())
+        if (pMethodDesc->IsIL())
         {
             COR_ILMETHOD_DECODER::DecoderStatus decoderstatus = COR_ILMETHOD_DECODER::FORMAT_ERROR;
             COR_ILMETHOD_DECODER ILHeader(pMethodDesc->GetILHeader(), pMethodDesc->GetMDImport(), &decoderstatus);
@@ -5359,7 +5367,7 @@ void ETW::MethodLog::SendMethodJitStartEvent(MethodDesc *pMethodDesc, SString *n
         }
 
         SString tNamespace, tMethodName, tMethodSignature;
-        if(!namespaceOrClassName|| !methodName|| !methodSignature || (methodName->IsEmpty() && namespaceOrClassName->IsEmpty() && methodSignature->IsEmpty()))
+        if (!namespaceOrClassName || !methodName || !methodSignature || (methodName->IsEmpty() && namespaceOrClassName->IsEmpty() && methodSignature->IsEmpty()))
         {
             pMethodDesc->GetMethodInfo(tNamespace, tMethodName, tMethodSignature);
             namespaceOrClassName = &tNamespace;
@@ -5387,35 +5395,35 @@ void ETW::MethodLog::SendMethodJitStartEvent(MethodDesc *pMethodDesc, SString *n
 #endif // !FEATURE_DTRACE
 
         FireEtwMethodJittingStarted_V1(ullMethodIdentifier,
-                                       ullModuleID,
-                                       ulMethodToken,
-                                       ulMethodILSize,
-                                       szDtraceOutput1,
-                                       szDtraceOutput2,
-                                       szDtraceOutput3,
-                                       GetClrInstanceId());
+            ullModuleID,
+            ulMethodToken,
+            ulMethodILSize,
+            szDtraceOutput1,
+            szDtraceOutput2,
+            szDtraceOutput3,
+            GetClrInstanceId());
     }
 }
 
 /****************************************************************************/
 /* This routine is used to send a method load/unload or rundown event                              */
 /****************************************************************************/
-void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptions, BOOL bIsJit, SString *namespaceOrClassName, SString *methodName, SString *methodSignature, SIZE_T pCode, ReJITID rejitID)
+void ETW::MethodLog::SendMethodEvent(MethodDesc* pMethodDesc, DWORD dwEventOptions, BOOL bIsJit, SString* namespaceOrClassName, SString* methodName, SString* methodSignature, SIZE_T pCode, ReJITID rejitID)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_NOTRIGGER;
         SO_NOT_MAINLINE;
     } CONTRACTL_END;
 
-    Module *pModule = NULL;
-    Module *pLoaderModule = NULL; // This must not be used except for getting the ModuleID
-    ULONGLONG ullMethodStartAddress=0, ullColdMethodStartAddress=0, ullModuleID=0, ullMethodIdentifier=0;
-    ULONG ulMethodSize=0, ulColdMethodSize=0, ulMethodToken=0, ulMethodFlags=0, ulColdMethodFlags=0;
-    PWCHAR pMethodName=NULL, pNamespaceName=NULL, pMethodSignature=NULL;
+    Module* pModule = NULL;
+    Module* pLoaderModule = NULL; // This must not be used except for getting the ModuleID
+    ULONGLONG ullMethodStartAddress = 0, ullColdMethodStartAddress = 0, ullModuleID = 0, ullMethodIdentifier = 0;
+    ULONG ulMethodSize = 0, ulColdMethodSize = 0, ulMethodToken = 0, ulMethodFlags = 0, ulColdMethodFlags = 0;
+    PWCHAR pMethodName = NULL, pNamespaceName = NULL, pMethodSignature = NULL;
     BOOL bHasNativeImage = FALSE, bShowVerboseOutput = FALSE, bIsDynamicMethod = FALSE, bHasSharedGenericCode = FALSE, bIsGenericMethod = FALSE;
 #ifndef FEATURE_DTRACE
-    PCWSTR szDtraceOutput1=L"",szDtraceOutput2=L"",szDtraceOutput3=L"";
+    PCWSTR szDtraceOutput1 = L"", szDtraceOutput2 = L"", szDtraceOutput3 = L"";
 #else
     CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
     CHAR szDtraceOutput2[DTRACE_OUTPUT_STRING_LEN];
@@ -5423,25 +5431,25 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
 #endif // !FEATURE_DTRACE
 
     BOOL bIsRundownProvider = ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodDCStart) ||
-                               (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodDCEnd) ||
-                               (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCStart) ||
-                               (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCEnd));
+        (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodDCEnd) ||
+        (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCStart) ||
+        (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCEnd));
 
     BOOL bIsRuntimeProvider = ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoad) ||
-                               (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnload) ||
-                               (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad) ||
-                               (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodUnload));
+        (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnload) ||
+        (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad) ||
+        (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodUnload));
 
     if (pMethodDesc == NULL)
         return;
 
-    if(!pMethodDesc->IsRestored())
+    if (!pMethodDesc->IsRestored())
     {
         // Forcibly restoring ngen methods can cause all sorts of deadlocks and contract violations
         // These events are therefore put under the private provider
-        if(ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context,
-                                        TRACE_LEVEL_INFORMATION,
-                                        CLR_PRIVATENGENFORCERESTORE_KEYWORD))
+        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context,
+            TRACE_LEVEL_INFORMATION,
+            CLR_PRIVATENGENFORCERESTORE_KEYWORD))
         {
             PERMANENT_CONTRACT_VIOLATION(GCViolation, ReasonNonShippingCode);
             pMethodDesc->CheckRestore();
@@ -5453,13 +5461,13 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
     }
 
 
-    if(bIsRundownProvider)
+    if (bIsRundownProvider)
     {
         bShowVerboseOutput = ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_RUNDOWN_PROVIDER_Context,
             TRACE_LEVEL_VERBOSE,
             KEYWORDZERO);
     }
-    else if(bIsRuntimeProvider)
+    else if (bIsRuntimeProvider)
     {
         bShowVerboseOutput = ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_Context,
             TRACE_LEVEL_VERBOSE,
@@ -5473,7 +5481,7 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
     bIsDynamicMethod = (BOOL)pMethodDesc->IsDynamicMethod();
     bHasSharedGenericCode = pMethodDesc->IsSharedByGenericInstantiations();
 
-    if(pMethodDesc->GetMethodTable_NoLogging())
+    if (pMethodDesc->GetMethodTable_NoLogging())
         bIsGenericMethod = pMethodDesc->HasClassOrMethodInstantiation_NoLogging();
 
     ulMethodFlags = ((ulMethodFlags |
@@ -5489,7 +5497,7 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
 
     // MethodDesc ==> Code Address ==>JitMananger
     TADDR start = pCode ? pCode : PCODEToPINSTR(pMethodDesc->GetNativeCode());
-    if(start == 0) {
+    if (start == 0) {
         // this method hasn't been jitted
         return;
     }
@@ -5505,22 +5513,22 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
     ullMethodStartAddress = (ULONGLONG)methodRegionInfo.hotStartAddress;
     ulMethodSize = (ULONG)methodRegionInfo.hotSize;
 
-    ullModuleID = (ULONGLONG)(TADDR) pModule;
+    ullModuleID = (ULONGLONG)(TADDR)pModule;
     ullMethodIdentifier = (ULONGLONG)pMethodDesc;
 
     // Use MethodDesc if Dynamic or Generic methods
-    if( bIsDynamicMethod || bIsGenericMethod)
+    if (bIsDynamicMethod || bIsGenericMethod)
     {
         bShowVerboseOutput = TRUE;
-        if(bIsGenericMethod)
+        if (bIsGenericMethod)
             ulMethodToken = (ULONG)pMethodDesc->GetMemberDef_NoLogging();
-        if(bIsDynamicMethod) // if its a generic and a dynamic method, we would set the methodtoken to 0
+        if (bIsDynamicMethod) // if its a generic and a dynamic method, we would set the methodtoken to 0
             ulMethodToken = (ULONG)0;
     }
     else
         ulMethodToken = (ULONG)pMethodDesc->GetMemberDef_NoLogging();
 
-    if(bHasNativeImage)
+    if (bHasNativeImage)
     {
         ullColdMethodStartAddress = (ULONGLONG)methodRegionInfo.coldStartAddress;
         ulColdMethodSize = (ULONG)methodRegionInfo.coldSize; // methodRegionInfo.coldSize is size_t and info.MethodLoadInfo.MethodSize is 32 bit; will give incorrect values on a 64-bit machine
@@ -5530,9 +5538,9 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
 
     // if verbose method load info needed, only then
     // find method name and signature and fire verbose method load info
-    if(bShowVerboseOutput)
+    if (bShowVerboseOutput)
     {
-        if(!namespaceOrClassName|| !methodName|| !methodSignature || (methodName->IsEmpty() && namespaceOrClassName->IsEmpty() && methodSignature->IsEmpty()))
+        if (!namespaceOrClassName || !methodName || !methodSignature || (methodName->IsEmpty() && namespaceOrClassName->IsEmpty() && methodSignature->IsEmpty()))
         {
             pMethodDesc->GetMethodInfo(tNamespace, tMethodName, tMethodSignature);
             namespaceOrClassName = &tNamespace;
@@ -5564,10 +5572,10 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
         return;
 #endif // !FEATURE_DTRACE
 
-    if((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoad) ||
+    if ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoad) ||
         (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad))
     {
-        if(bShowVerboseOutput)
+        if (bShowVerboseOutput)
         {
             FireEtwMethodLoadVerbose_V1_or_V2(ullMethodIdentifier,
                 ullModuleID,
@@ -5592,9 +5600,9 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
                 GetClrInstanceId(),
                 rejitID);
         }
-        if(bFireEventForColdSection)
+        if (bFireEventForColdSection)
         {
-            if(bShowVerboseOutput)
+            if (bShowVerboseOutput)
             {
                 FireEtwMethodLoadVerbose_V1_or_V2(ullMethodIdentifier,
                     ullModuleID,
@@ -5621,10 +5629,10 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
             }
         }
     }
-    else if((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnload) ||
+    else if ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnload) ||
         (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodUnload))
     {
-        if(bShowVerboseOutput)
+        if (bShowVerboseOutput)
         {
             FireEtwMethodUnloadVerbose_V1_or_V2(ullMethodIdentifier,
                 ullModuleID,
@@ -5649,9 +5657,9 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
                 GetClrInstanceId(),
                 rejitID);
         }
-        if(bFireEventForColdSection)
+        if (bFireEventForColdSection)
         {
-            if(bShowVerboseOutput)
+            if (bShowVerboseOutput)
             {
                 FireEtwMethodUnloadVerbose_V1_or_V2(ullMethodIdentifier,
                     ullModuleID,
@@ -5678,10 +5686,10 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
             }
         }
     }
-    else if((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodDCStart) ||
+    else if ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodDCStart) ||
         (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCStart))
     {
-        if(bShowVerboseOutput)
+        if (bShowVerboseOutput)
         {
             FireEtwMethodDCStartVerbose_V1_or_V2(ullMethodIdentifier,
                 ullModuleID,
@@ -5706,9 +5714,9 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
                 GetClrInstanceId(),
                 rejitID);
         }
-        if(bFireEventForColdSection)
+        if (bFireEventForColdSection)
         {
-            if(bShowVerboseOutput)
+            if (bShowVerboseOutput)
             {
                 FireEtwMethodDCStartVerbose_V1_or_V2(ullMethodIdentifier,
                     ullModuleID,
@@ -5735,10 +5743,10 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
             }
         }
     }
-    else if((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodDCEnd) ||
+    else if ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodDCEnd) ||
         (dwEventOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCEnd))
     {
-        if(bShowVerboseOutput)
+        if (bShowVerboseOutput)
         {
             FireEtwMethodDCEndVerbose_V1_or_V2(ullMethodIdentifier,
                 ullModuleID,
@@ -5763,9 +5771,9 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
                 GetClrInstanceId(),
                 rejitID);
         }
-        if(bFireEventForColdSection)
+        if (bFireEventForColdSection)
         {
-            if(bShowVerboseOutput)
+            if (bShowVerboseOutput)
             {
                 FireEtwMethodDCEndVerbose_V1_or_V2(ullMethodIdentifier,
                     ullModuleID,
@@ -5822,7 +5830,7 @@ void ETW::MethodLog::SendMethodEvent(MethodDesc *pMethodDesc, DWORD dwEventOptio
 //
 
 // static
-void ETW::MethodLog::SendMethodILToNativeMapEvent(MethodDesc * pMethodDesc, DWORD dwEventOptions, ReJITID rejitID)
+void ETW::MethodLog::SendMethodILToNativeMapEvent(MethodDesc* pMethodDesc, DWORD dwEventOptions, ReJITID rejitID)
 {
     CONTRACTL
     {
@@ -5899,42 +5907,42 @@ void ETW::MethodLog::SendMethodILToNativeMapEvent(MethodDesc * pMethodDesc, DWOR
 void ETW::MethodLog::SendHelperEvent(ULONGLONG ullHelperStartAddress, ULONG ulHelperSize, LPCWSTR pHelperName)
 {
     WRAPPER_NO_CONTRACT;
-    if(pHelperName)
+    if (pHelperName)
     {
 #ifndef FEATURE_DTRACE
-         PCWSTR szDtraceOutput1=L"";
+        PCWSTR szDtraceOutput1 = L"";
 #else
-         CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
+        CHAR szDtraceOutput1[DTRACE_OUTPUT_STRING_LEN];
 #endif // !FEATURE_DTRACE
-         ULONG methodFlags = ETW::MethodLog::MethodStructs::JitHelperMethod; // helper flag set
+        ULONG methodFlags = ETW::MethodLog::MethodStructs::JitHelperMethod; // helper flag set
 #ifndef FEATURE_DTRACE
-         FireEtwMethodLoadVerbose_V1(ullHelperStartAddress,
-                                     0,
-                                     ullHelperStartAddress,
-                                     ulHelperSize,
-                                     0,
-                                     methodFlags,
-                                     NULL,
-                                     pHelperName,
-                                     NULL,
-                                     GetClrInstanceId());
+        FireEtwMethodLoadVerbose_V1(ullHelperStartAddress,
+            0,
+            ullHelperStartAddress,
+            ulHelperSize,
+            0,
+            methodFlags,
+            NULL,
+            pHelperName,
+            NULL,
+            GetClrInstanceId());
 #else // !FEATURE_DTRACE
          // since DTrace do not support UNICODE string, they need to be converted to ANSI string
-         INT32 nTempHelperName = WideCharToMultiByte(pHelperName, szDtraceOutput1);
-         if (nTempHelperName == 0)
-             return;
-         // in the action, printf, of DTtrace, it cannot print an arg with value NULL when the format is set %s.
-         // Dtrace does not provide the condition statement so that we give a string "NULL" to it.
-         FireEtwMethodLoadVerbose_V1(ullHelperStartAddress,
-                                     0,
-                                     ullHelperStartAddress,
-                                     ulHelperSize,
-                                     0,
-                                     methodFlags,
-                                     szDtraceOutputNULL,
-                                     szDtraceOutput1,
-                                     szDtraceOutputNULL,
-                                     GetClrInstanceId());
+        INT32 nTempHelperName = WideCharToMultiByte(pHelperName, szDtraceOutput1);
+        if (nTempHelperName == 0)
+            return;
+        // in the action, printf, of DTtrace, it cannot print an arg with value NULL when the format is set %s.
+        // Dtrace does not provide the condition statement so that we give a string "NULL" to it.
+        FireEtwMethodLoadVerbose_V1(ullHelperStartAddress,
+            0,
+            ullHelperStartAddress,
+            ulHelperSize,
+            0,
+            methodFlags,
+            szDtraceOutputNULL,
+            szDtraceOutput1,
+            szDtraceOutputNULL,
+            GetClrInstanceId());
 #endif // !FEATURE_DTRACE
     }
 }
@@ -5943,23 +5951,23 @@ void ETW::MethodLog::SendHelperEvent(ULONGLONG ullHelperStartAddress, ULONG ulHe
 /****************************************************************************/
 /* This routine sends back method events of type 'dwEventOptions', for all
    NGEN methods in pModule */
-/****************************************************************************/
-void ETW::MethodLog::SendEventsForNgenMethods(Module *pModule, DWORD dwEventOptions)
+   /****************************************************************************/
+void ETW::MethodLog::SendEventsForNgenMethods(Module* pModule, DWORD dwEventOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
 
 #ifdef FEATURE_PREJIT
-    if(!pModule || !pModule->HasNativeImage())
+    if (!pModule || !pModule->HasNativeImage())
         return;
 
     MethodIterator mi(pModule);
 
-    while(mi.Next())
+    while (mi.Next())
     {
-        MethodDesc *hotDesc = (MethodDesc *)mi.GetMethodDesc();
+        MethodDesc* hotDesc = (MethodDesc*)mi.GetMethodDesc();
         ETW::MethodLog::SendMethodEvent(hotDesc, dwEventOptions, FALSE);
     }
 #endif // FEATURE_PREJIT
@@ -5970,10 +5978,10 @@ void ETW::MethodLog::SendEventsForNgenMethods(Module *pModule, DWORD dwEventOpti
    JITed methods in either a given LoaderAllocator (if pLoaderAllocatorFilter is non NULL)
    or in a given Domain (if pDomainFilter is non NULL) or for
    all methods (if both filters are null) */
-/****************************************************************************/
-void ETW::MethodLog::SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAllocator *pLoaderAllocatorFilter, DWORD dwEventOptions)
+   /****************************************************************************/
+void ETW::MethodLog::SendEventsForJitMethods(BaseDomain* pDomainFilter, LoaderAllocator* pLoaderAllocatorFilter, DWORD dwEventOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
@@ -5983,19 +5991,19 @@ void ETW::MethodLog::SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAl
     // This is only called for JITted methods loading xor unloading
     BOOL fLoadOrDCStart = ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoadOrDCStartAny) != 0);
     BOOL fUnloadOrDCEnd = ((dwEventOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnloadOrDCEndAny) != 0);
-    _ASSERTE((fLoadOrDCStart || fUnloadOrDCEnd) && !(fLoadOrDCStart && fUnloadOrDCEnd));
+    _ASSERTE((fLoadOrDCStart || fUnloadOrDCEnd) && !(fLoadOrDCStart&& fUnloadOrDCEnd));
 
     BOOL fSendMethodEvent =
         (dwEventOptions &
             (ETW::EnumerationLog::EnumerationStructs::JitMethodLoad |
-            ETW::EnumerationLog::EnumerationStructs::JitMethodDCStart |
-            ETW::EnumerationLog::EnumerationStructs::JitMethodUnload |
-            ETW::EnumerationLog::EnumerationStructs::JitMethodDCEnd)) != 0;
+                ETW::EnumerationLog::EnumerationStructs::JitMethodDCStart |
+                ETW::EnumerationLog::EnumerationStructs::JitMethodUnload |
+                ETW::EnumerationLog::EnumerationStructs::JitMethodDCEnd)) != 0;
 
     BOOL fSendILToNativeMapEvent =
         (dwEventOptions &
             (ETW::EnumerationLog::EnumerationStructs::MethodDCStartILToNativeMap |
-            ETW::EnumerationLog::EnumerationStructs::MethodDCEndILToNativeMap)) != 0;
+                ETW::EnumerationLog::EnumerationStructs::MethodDCEndILToNativeMap)) != 0;
 
     BOOL fCollectibleLoaderAllocatorFilter =
         ((pLoaderAllocatorFilter != NULL) && (pLoaderAllocatorFilter->IsCollectible()));
@@ -6014,9 +6022,9 @@ void ETW::MethodLog::SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAl
 #endif // WINXP_AND_WIN2K3_BUILD_SUPPORT
 
     EEJitManager::CodeHeapIterator heapIterator(pDomainFilter, pLoaderAllocatorFilter);
-    while(heapIterator.Next())
+    while (heapIterator.Next())
     {
-        MethodDesc * pMD = heapIterator.GetMethod();
+        MethodDesc* pMD = heapIterator.GetMethod();
         if (pMD == NULL)
             continue;
 
@@ -6103,7 +6111,7 @@ void ETW::MethodLog::SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAl
 //      enumerationOptions - Flags indicating what to enumerate.  Just passed
 //         straight through to IterateDomain
 //
-void ETW::EnumerationLog::IterateAppDomain(AppDomain * pAppDomain, DWORD enumerationOptions)
+void ETW::EnumerationLog::IterateAppDomain(AppDomain* pAppDomain, DWORD enumerationOptions)
 {
     CONTRACTL
     {
@@ -6143,10 +6151,10 @@ void ETW::EnumerationLog::IterateAppDomain(AppDomain * pAppDomain, DWORD enumera
    JIT methods in them,
    and the NGEN methods in them
    based on enumerationOptions.*/
-/********************************************************************************/
-void ETW::EnumerationLog::IterateDomain(BaseDomain *pDomain, DWORD enumerationOptions)
+   /********************************************************************************/
+void ETW::EnumerationLog::IterateDomain(BaseDomain* pDomain, DWORD enumerationOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
         PRECONDITION(pDomain != NULL);
@@ -6166,86 +6174,86 @@ void ETW::EnumerationLog::IterateDomain(BaseDomain *pDomain, DWORD enumerationOp
     EX_TRY
     {
         // DC Start events for Domain
-        if(enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
+        if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
         {
             ETW::LoaderLog::SendDomainEvent(pDomain, enumerationOptions);
         }
 
-        // DC End or Unload Jit Method events
-        if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnloadOrDCEndAny)
-        {
-            ETW::MethodLog::SendEventsForJitMethods(pDomain, NULL, enumerationOptions);
-        }
+    // DC End or Unload Jit Method events
+    if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnloadOrDCEndAny)
+    {
+        ETW::MethodLog::SendEventsForJitMethods(pDomain, NULL, enumerationOptions);
+    }
 
-        if (pDomain->IsAppDomain())
+    if (pDomain->IsAppDomain())
+    {
+        AppDomain::AssemblyIterator assemblyIterator = pDomain->AsAppDomain()->IterateAssembliesEx(
+            (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution));
+        CollectibleAssemblyHolder<DomainAssembly*> pDomainAssembly;
+        while (assemblyIterator.Next(pDomainAssembly.This()))
         {
-            AppDomain::AssemblyIterator assemblyIterator = pDomain->AsAppDomain()->IterateAssembliesEx(
-                (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution));
-            CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
-            while (assemblyIterator.Next(pDomainAssembly.This()))
+            CollectibleAssemblyHolder<Assembly*> pAssembly = pDomainAssembly->GetLoadedAssembly();
+            BOOL bIsDomainNeutral = pAssembly->IsDomainNeutral();
+            if (bIsDomainNeutral)
+                continue;
+            if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
             {
-                CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetLoadedAssembly();
-                BOOL bIsDomainNeutral = pAssembly->IsDomainNeutral();
-                if (bIsDomainNeutral)
-                    continue;
-                if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
-                {
-                    ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
-                }
+                ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
+            }
 
-                DomainModuleIterator domainModuleIterator = pDomainAssembly->IterateModules(kModIterIncludeLoaded);
-                while (domainModuleIterator.Next())
-                {
-                    Module * pModule = domainModuleIterator.GetModule();
-                    ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
-                }
+            DomainModuleIterator domainModuleIterator = pDomainAssembly->IterateModules(kModIterIncludeLoaded);
+            while (domainModuleIterator.Next())
+            {
+                Module* pModule = domainModuleIterator.GetModule();
+                ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
+            }
 
-                if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
-                   (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
-                {
-                    ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
-                }
+            if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
+               (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
+            {
+                ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
             }
         }
-        else
+    }
+    else
+    {
+        SharedDomain::SharedAssemblyIterator sharedDomainIterator;
+        while (sharedDomainIterator.Next())
         {
-            SharedDomain::SharedAssemblyIterator sharedDomainIterator;
-            while (sharedDomainIterator.Next())
+            Assembly* pAssembly = sharedDomainIterator.GetAssembly();
+            if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
             {
-                Assembly * pAssembly = sharedDomainIterator.GetAssembly();
-                if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
-                {
-                    ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
-                }
+                ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
+            }
 
-                ModuleIterator domainModuleIterator = pAssembly->IterateModules();
-                while (domainModuleIterator.Next())
-                {
-                    Module * pModule = domainModuleIterator.GetModule();
-                    ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
-                }
+            ModuleIterator domainModuleIterator = pAssembly->IterateModules();
+            while (domainModuleIterator.Next())
+            {
+                Module* pModule = domainModuleIterator.GetModule();
+                ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
+            }
 
-                if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
-                    (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
-                {
-                    ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
-                }
+            if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
+                (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
+            {
+                ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
             }
         }
+    }
 
-        // DC Start or Load Jit Method events
-        if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoadOrDCStartAny)
-        {
-            ETW::MethodLog::SendEventsForJitMethods(pDomain, NULL, enumerationOptions);
-        }
+    // DC Start or Load Jit Method events
+    if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoadOrDCStartAny)
+    {
+        ETW::MethodLog::SendEventsForJitMethods(pDomain, NULL, enumerationOptions);
+    }
 
-        // DC End or Unload events for Domain
-        if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
-        {
-            ETW::LoaderLog::SendDomainEvent(pDomain, enumerationOptions);
-        }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    // DC End or Unload events for Domain
+    if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
+    {
+        ETW::LoaderLog::SendDomainEvent(pDomain, enumerationOptions);
+    }
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 
@@ -6257,10 +6265,10 @@ void ETW::EnumerationLog::IterateDomain(BaseDomain *pDomain, DWORD enumerationOp
    JIT methods in them,
    and the NGEN methods in them
    based on enumerationOptions.*/
-/********************************************************************************/
-void ETW::EnumerationLog::IterateCollectibleLoaderAllocator(AssemblyLoaderAllocator *pLoaderAllocator, DWORD enumerationOptions)
+   /********************************************************************************/
+void ETW::EnumerationLog::IterateCollectibleLoaderAllocator(AssemblyLoaderAllocator* pLoaderAllocator, DWORD enumerationOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
         PRECONDITION(pLoaderAllocator != NULL);
@@ -6274,13 +6282,13 @@ void ETW::EnumerationLog::IterateCollectibleLoaderAllocator(AssemblyLoaderAlloca
             ETW::MethodLog::SendEventsForJitMethods(NULL, pLoaderAllocator, enumerationOptions);
         }
 
-        Assembly *pAssembly = pLoaderAllocator->Id()->GetDomainAssembly()->GetAssembly();
+        Assembly* pAssembly = pLoaderAllocator->Id()->GetDomainAssembly()->GetAssembly();
         _ASSERTE(!pAssembly->IsDomainNeutral()); // Collectible Assemblies are not domain neutral.
 
         DomainModuleIterator domainModuleIterator = pLoaderAllocator->Id()->GetDomainAssembly()->IterateModules(kModIterIncludeLoaded);
         while (domainModuleIterator.Next())
         {
-            Module *pModule = domainModuleIterator.GetModule();
+            Module* pModule = domainModuleIterator.GetModule();
             ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
         }
 
@@ -6294,16 +6302,16 @@ void ETW::EnumerationLog::IterateCollectibleLoaderAllocator(AssemblyLoaderAlloca
         {
             ETW::MethodLog::SendEventsForJitMethods(NULL, pLoaderAllocator, enumerationOptions);
         }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /********************************************************************************/
 /* This routine fires ETW events for Assembly and the DomainModule's in them
    based on enumerationOptions.*/
-/********************************************************************************/
-void ETW::EnumerationLog::IterateAssembly(Assembly *pAssembly, DWORD enumerationOptions)
+   /********************************************************************************/
+void ETW::EnumerationLog::IterateAssembly(Assembly* pAssembly, DWORD enumerationOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
         PRECONDITION(pAssembly != NULL);
@@ -6312,41 +6320,41 @@ void ETW::EnumerationLog::IterateAssembly(Assembly *pAssembly, DWORD enumeration
     EX_TRY
     {
         // DC Start events for Assembly
-        if(enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
+        if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
         {
             ETW::LoaderLog::SendAssemblyEvent(pAssembly, enumerationOptions);
         }
 
-        // DC Start, DCEnd, events for DomainModule
-        if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart))
+    // DC Start, DCEnd, events for DomainModule
+    if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart))
+    {
+        if (pAssembly->GetDomain()->IsAppDomain())
         {
-            if(pAssembly->GetDomain()->IsAppDomain())
+            DomainModuleIterator dmIterator = pAssembly->FindDomainAssembly(pAssembly->GetDomain()->AsAppDomain())->IterateModules(kModIterIncludeLoaded);
+            while (dmIterator.Next())
             {
-                DomainModuleIterator dmIterator = pAssembly->FindDomainAssembly(pAssembly->GetDomain()->AsAppDomain())->IterateModules(kModIterIncludeLoaded);
-                while (dmIterator.Next())
-                {
-                    ETW::LoaderLog::SendModuleEvent(dmIterator.GetModule(), enumerationOptions, TRUE);
-                }
+                ETW::LoaderLog::SendModuleEvent(dmIterator.GetModule(), enumerationOptions, TRUE);
             }
         }
+    }
 
-        // DC End or Unload events for Assembly
-        if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
-        {
-            ETW::LoaderLog::SendAssemblyEvent(pAssembly, enumerationOptions);
-        }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    // DC End or Unload events for Assembly
+    if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
+    {
+        ETW::LoaderLog::SendAssemblyEvent(pAssembly, enumerationOptions);
+    }
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 /********************************************************************************/
 /* This routine fires ETW events for Module, their range information and the NGEN methods in them
    based on enumerationOptions.*/
-/********************************************************************************/
-void ETW::EnumerationLog::IterateModule(Module *pModule, DWORD enumerationOptions)
+   /********************************************************************************/
+void ETW::EnumerationLog::IterateModule(Module* pModule, DWORD enumerationOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
         PRECONDITION(pModule != NULL);
@@ -6355,45 +6363,45 @@ void ETW::EnumerationLog::IterateModule(Module *pModule, DWORD enumerationOption
     EX_TRY
     {
         // DC Start events for Module
-        if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
+        if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) ||
            (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCStart))
         {
             ETW::LoaderLog::SendModuleEvent(pModule, enumerationOptions);
         }
 
-        // DC Start or Load or DC End or Unload Ngen Method events
-        if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCStart) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodUnload) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCEnd))
-        {
-            ETW::MethodLog::SendEventsForNgenMethods(pModule, enumerationOptions);
-        }
+    // DC Start or Load or DC End or Unload Ngen Method events
+    if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodLoad) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCStart) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodUnload) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::NgenMethodDCEnd))
+    {
+        ETW::MethodLog::SendEventsForNgenMethods(pModule, enumerationOptions);
+    }
 
-        // DC End or Unload events for Module
-        if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
-           (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCEnd))
-        {
-            ETW::LoaderLog::SendModuleEvent(pModule, enumerationOptions);
-        }
+    // DC End or Unload events for Module
+    if ((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload) ||
+       (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeDCEnd))
+    {
+        ETW::LoaderLog::SendModuleEvent(pModule, enumerationOptions);
+    }
 
-        // If we're logging types, then update the internal Type hash table to account
-        // for the module's unloading
-        if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::TypeUnload)
-        {
-            ETW::TypeSystemLog::OnModuleUnload(pModule);
-        }
+    // If we're logging types, then update the internal Type hash table to account
+    // for the module's unloading
+    if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::TypeUnload)
+    {
+        ETW::TypeSystemLog::OnModuleUnload(pModule);
+    }
 
-        // ModuleRangeLoadPrivate events for module range information from attach/detach scenarios
-        if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context,
-                                         TRACE_LEVEL_INFORMATION,
-                                         CLR_PERFTRACK_PRIVATE_KEYWORD) &&
-            (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoadPrivate))
-        {
-            ETW::LoaderLog::SendModuleEvent(pModule, enumerationOptions);
-        }
-    } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions);
+    // ModuleRangeLoadPrivate events for module range information from attach/detach scenarios
+    if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PRIVATE_PROVIDER_Context,
+                                     TRACE_LEVEL_INFORMATION,
+                                     CLR_PERFTRACK_PRIVATE_KEYWORD) &&
+        (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoadPrivate))
+    {
+        ETW::LoaderLog::SendModuleEvent(pModule, enumerationOptions);
+    }
+    } EX_CATCH{ } EX_END_CATCH(SwallowAllExceptions);
 }
 
 //---------------------------------------------------------------------------------------
@@ -6429,9 +6437,9 @@ void ETW::EnumerationLog::IterateModule(Module *pModule, DWORD enumerationOption
 //
 
 // static
-void ETW::EnumerationLog::EnumerationHelper(Module *moduleFilter, BaseDomain *domainFilter, DWORD enumerationOptions)
+void ETW::EnumerationLog::EnumerationHelper(Module* moduleFilter, BaseDomain* domainFilter, DWORD enumerationOptions)
 {
-    CONTRACTL {
+    CONTRACTL{
         THROWS;
         GC_TRIGGERS;
     } CONTRACTL_END;
@@ -6444,7 +6452,7 @@ void ETW::EnumerationLog::EnumerationHelper(Module *moduleFilter, BaseDomain *do
     // See code:#TableLockHolder
     ReJitManager::TableLockHolder lkRejitMgrSharedDomain(SharedDomain::GetDomain()->GetReJitManager());
 
-    if(moduleFilter)
+    if (moduleFilter)
     {
         // See code:#TableLockHolder
         ReJitManager::TableLockHolder lkRejitMgrModule(moduleFilter->GetReJitManager());
@@ -6466,12 +6474,12 @@ void ETW::EnumerationLog::EnumerationHelper(Module *moduleFilter, BaseDomain *do
     }
     else
     {
-        if(domainFilter)
+        if (domainFilter)
         {
             // See code:#TableLockHolder
             ReJitManager::TableLockHolder lkRejitMgrAD(domainFilter->GetReJitManager());
 
-            if(domainFilter->IsAppDomain())
+            if (domainFilter->IsAppDomain())
             {
                 ETW::EnumerationLog::IterateAppDomain(domainFilter->AsAppDomain(), enumerationOptions);
             }
@@ -6483,9 +6491,9 @@ void ETW::EnumerationLog::EnumerationHelper(Module *moduleFilter, BaseDomain *do
         else
         {
             AppDomainIterator appDomainIterator(FALSE);
-            while(appDomainIterator.Next())
+            while (appDomainIterator.Next())
             {
-                AppDomain *pDomain = appDomainIterator.GetDomain();
+                AppDomain* pDomain = appDomainIterator.GetDomain();
                 if (pDomain != NULL)
                 {
                     // See code:#TableLockHolder
diff --git a/src/coreclr/vm/CMakeLists.txt b/src/coreclr/vm/CMakeLists.txt
index e063b7ad3677c2..08a5bb92a66ed7 100644
--- a/src/coreclr/vm/CMakeLists.txt
+++ b/src/coreclr/vm/CMakeLists.txt
@@ -63,7 +63,7 @@ set(VM_SOURCES_DAC_AND_WKS_COMMON
     debuginfostore.cpp
     decodemd.cpp
     disassembler.cpp
-    domainfile.cpp
+    domainassembly.cpp
     dynamicmethod.cpp
     ecall.cpp
     eedbginterfaceimpl.cpp
@@ -161,8 +161,7 @@ set(VM_HEADERS_DAC_AND_WKS_COMMON
     debuginfostore.h
     decodemd.h
     disassembler.h
-    domainfile.h
-    domainfile.inl
+    domainassembly.h
     dynamicmethod.h
     ecall.h
     eedbginterfaceimpl.h
diff --git a/src/coreclr/vm/appdomain.cpp b/src/coreclr/vm/appdomain.cpp
index 2aa55d6d5128fb..80e22d4f7f209a 100644
--- a/src/coreclr/vm/appdomain.cpp
+++ b/src/coreclr/vm/appdomain.cpp
@@ -1321,10 +1321,10 @@ void SystemDomain::LoadBaseSystemClasses()
 
     // Only partially load the system assembly. Other parts of the code will want to access
     // the globals in this function before finishing the load.
-    m_pSystemAssembly = DefaultDomain()->LoadDomainAssembly(NULL, m_pSystemPEAssembly, FILE_LOAD_POST_LOADLIBRARY)->GetCurrentAssembly();
+    m_pSystemAssembly = DefaultDomain()->LoadDomainAssembly(NULL, m_pSystemPEAssembly, FILE_LOAD_POST_LOADLIBRARY)->GetAssembly();
 
     // Set up binder for CoreLib
-    CoreLibBinder::AttachModule(m_pSystemAssembly->GetManifestModule());
+    CoreLibBinder::AttachModule(m_pSystemAssembly->GetModule());
 
     // Load Object
     g_pObjectClass = CoreLibBinder::GetClass(CLASS__OBJECT);
@@ -2173,7 +2173,7 @@ BOOL AppDomain::ContainsAssembly(Assembly * assem)
 
     while (i.Next(pDomainAssembly.This()))
     {
-        CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetLoadedAssembly();
+        CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetAssembly();
         if (pAssembly == assem)
             return TRUE;
     }
@@ -2238,7 +2238,7 @@ DispIDCache* AppDomain::SetupRefDispIDCache()
 
 #endif // FEATURE_COMINTEROP
 
-FileLoadLock *FileLoadLock::Create(PEFileListLock *pLock, PEAssembly * pPEAssembly, DomainFile *pDomainFile)
+FileLoadLock *FileLoadLock::Create(PEFileListLock *pLock, PEAssembly * pPEAssembly, DomainAssembly *pDomainAssembly)
 {
     CONTRACTL
     {
@@ -2251,7 +2251,7 @@ FileLoadLock *FileLoadLock::Create(PEFileListLock *pLock, PEAssembly * pPEAssemb
     }
     CONTRACTL_END;
 
-    NewHolder<FileLoadLock> result(new FileLoadLock(pLock, pPEAssembly, pDomainFile));
+    NewHolder<FileLoadLock> result(new FileLoadLock(pLock, pPEAssembly, pDomainAssembly));
 
     pLock->AddElement(result);
     result->AddRef(); // Add one ref on behalf of the ListLock's reference. The corresponding Release() happens in FileLoadLock::CompleteLoadLevel.
@@ -2271,10 +2271,10 @@ FileLoadLock::~FileLoadLock()
     ((PEAssembly *) m_data)->Release();
 }
 
-DomainFile *FileLoadLock::GetDomainFile()
+DomainAssembly *FileLoadLock::GetDomainAssembly()
 {
     LIMITED_METHOD_CONTRACT;
-    return m_pDomainFile;
+    return m_pDomainAssembly;
 }
 
 FileLoadLevel FileLoadLock::GetLoadLevel()
@@ -2356,7 +2356,7 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success)
     if (level > m_level)
     {
         // Must complete each level in turn, unless we have an error
-        CONSISTENCY_CHECK(m_pDomainFile->IsError() || (level == (m_level+1)));
+        CONSISTENCY_CHECK(m_pDomainAssembly->IsError() || (level == (m_level+1)));
         // Remove the lock from the list if the load is completed
         if (level >= FILE_ACTIVE)
         {
@@ -2370,18 +2370,18 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success)
                     m_pList->Unlink(this);
                 _ASSERTE(fDbgOnly_SuccessfulUnlink);
 
-                m_pDomainFile->ClearLoading();
+                m_pDomainAssembly->ClearLoading();
 
-                CONSISTENCY_CHECK(m_dwRefCount >= 2); // Caller (LoadDomainFile) should have 1 refcount and m_pList should have another which was acquired in FileLoadLock::Create.
+                CONSISTENCY_CHECK(m_dwRefCount >= 2); // Caller (LoadDomainAssembly) should have 1 refcount and m_pList should have another which was acquired in FileLoadLock::Create.
 
                 m_level = (FileLoadLevel)level;
 
                 // Dev11 bug 236344
                 // In AppDomain::IsLoading, if the lock is taken on m_pList and then FindFileLock returns NULL,
-                // we depend on the DomainFile's load level being up to date. Hence we must update the load
+                // we depend on the DomainAssembly's load level being up to date. Hence we must update the load
                 // level while the m_pList lock is held.
                 if (success)
-                    m_pDomainFile->SetLoadLevel(level);
+                    m_pDomainAssembly->SetLoadLevel(level);
             }
 
 
@@ -2393,7 +2393,7 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success)
             m_level = (FileLoadLevel)level;
 
             if (success)
-                m_pDomainFile->SetLoadLevel(level);
+                m_pDomainAssembly->SetLoadLevel(level);
         }
 
 #ifndef DACCESS_COMPILE
@@ -2404,7 +2404,7 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success)
             case FILE_LOAD_DELIVER_EVENTS:
             case FILE_LOADED:
             case FILE_ACTIVE: // The timing of stress logs is not critical, so even for the FILE_ACTIVE stage we need not do it while the m_pList lock is held.
-                STRESS_LOG3(LF_CLASSLOADER, LL_INFO100, "Completed Load Level %s for DomainFile %p - success = %i\n", fileLoadLevelName[level], m_pDomainFile, success);
+                STRESS_LOG3(LF_CLASSLOADER, LL_INFO100, "Completed Load Level %s for DomainAssembly %p - success = %i\n", fileLoadLevelName[level], m_pDomainAssembly, success);
                 break;
             default:
                 break;
@@ -2433,9 +2433,9 @@ void FileLoadLock::SetError(Exception *ex)
     m_cachedHR = ex->GetHR();
 
     LOG((LF_LOADER, LL_WARNING, "LOADER: %x:***%s*\t!!!Non-transient error 0x%x\n",
-         m_pDomainFile->GetAppDomain(), m_pDomainFile->GetSimpleName(), m_cachedHR));
+         m_pDomainAssembly->GetAppDomain(), m_pDomainAssembly->GetSimpleName(), m_cachedHR));
 
-    m_pDomainFile->SetError(ex);
+    m_pDomainAssembly->SetError(ex);
 
     CompleteLoadLevel(FILE_ACTIVE, FALSE);
 }
@@ -2463,10 +2463,10 @@ UINT32 FileLoadLock::Release()
     return count;
 }
 
-FileLoadLock::FileLoadLock(PEFileListLock *pLock, PEAssembly * pPEAssembly, DomainFile *pDomainFile)
+FileLoadLock::FileLoadLock(PEFileListLock *pLock, PEAssembly * pPEAssembly, DomainAssembly *pDomainAssembly)
   : ListLockEntry(pLock, pPEAssembly, "File load lock"),
     m_level((FileLoadLevel) (FILE_LOAD_CREATE)),
-    m_pDomainFile(pDomainFile),
+    m_pDomainAssembly(pDomainAssembly),
     m_cachedHR(S_OK)
 {
     WRAPPER_NO_CONTRACT;
@@ -2521,26 +2521,6 @@ void AppDomain::LoadSystemAssemblies()
     LoadAssembly(NULL, SystemDomain::System()->SystemPEAssembly(), FILE_ACTIVE);
 }
 
-FileLoadLevel AppDomain::GetDomainFileLoadLevel(DomainFile *pFile)
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    LoadLockHolder lock(this);
-
-    FileLoadLock* pLockEntry = (FileLoadLock *) lock->FindFileLock(pFile->GetPEAssembly());
-
-    if (pLockEntry == NULL)
-        return pFile->GetLoadLevel();
-    else
-        return pLockEntry->GetLoadLevel();
-}
-
 // This checks if the thread has initiated (or completed) loading at the given level.  A false guarantees that
 // (a) The current thread (or a thread blocking on the current thread) has not started loading the file
 //      at the given level, and
@@ -2554,7 +2534,7 @@ FileLoadLevel AppDomain::GetDomainFileLoadLevel(DomainFile *pFile)
 // thread has completed the load step.
 //
 
-BOOL AppDomain::IsLoading(DomainFile *pFile, FileLoadLevel level)
+BOOL AppDomain::IsLoading(DomainAssembly *pFile, FileLoadLevel level)
 {
     // Cheap out
     if (pFile->GetLoadLevel() < level)
@@ -2591,7 +2571,7 @@ BOOL AppDomain::IsLoading(DomainFile *pFile, FileLoadLevel level)
 
 // CheckLoading is a weaker form of IsLoading, which will not block on
 // other threads waiting for their status.  This is appropriate for asserts.
-CHECK AppDomain::CheckLoading(DomainFile *pFile, FileLoadLevel level)
+CHECK AppDomain::CheckLoading(DomainAssembly *pFile, FileLoadLevel level)
 {
     // Cheap out
     if (pFile->GetLoadLevel() < level)
@@ -2625,7 +2605,7 @@ CHECK AppDomain::CheckCanLoadTypes(Assembly *pAssembly)
         MODE_ANY;
     }
     CONTRACTL_END;
-    CHECK_MSG(CheckValidModule(pAssembly->GetManifestModule()),
+    CHECK_MSG(CheckValidModule(pAssembly->GetModule()),
               "Type loading can occur only when executing in the assembly's app domain");
     CHECK_OK;
 }
@@ -2657,7 +2637,7 @@ CHECK AppDomain::CheckCanExecuteManagedCode(MethodDesc* pMD)
 
 #endif // !DACCESS_COMPILE
 
-void AppDomain::LoadDomainFile(DomainFile *pFile,
+void AppDomain::LoadDomainAssembly(DomainAssembly *pFile,
                                FileLoadLevel targetLevel)
 {
     CONTRACTL
@@ -2697,7 +2677,7 @@ void AppDomain::LoadDomainFile(DomainFile *pFile,
 
         lock.Release();
 
-        LoadDomainFile(pLockEntry, targetLevel);
+        LoadDomainAssembly(pLockEntry, targetLevel);
     }
 
 #else // DACCESS_COMPILE
@@ -2874,12 +2854,12 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity,
 
         if (result == NULL)
         {
-            // We pass our ref on fileLock to LoadDomainFile to release.
+            // We pass our ref on fileLock to LoadDomainAssembly to release.
 
             // Note that if we throw here, we will poison fileLock with an error condition,
             // so it will not be removed until app domain unload.  So there is no need
             // to release our ref count.
-            result = (DomainAssembly *)LoadDomainFile(fileLock, targetLevel);
+            result = (DomainAssembly *)LoadDomainAssembly(fileLock, targetLevel);
         }
         else
         {
@@ -2888,20 +2868,12 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity,
 
         if (registerNewAssembly)
         {
-            pPEAssembly->GetAssemblyBinder()->AddLoadedAssembly(pDomainAssembly->GetCurrentAssembly());
+            pPEAssembly->GetAssemblyBinder()->AddLoadedAssembly(pDomainAssembly->GetAssembly());
         }
     }
     else
         result->EnsureLoadLevel(targetLevel);
 
-    // Malformed metadata may contain a Module reference to what is actually
-    // an Assembly. In this case we need to throw an exception, since returning
-    // a DomainModule as a DomainAssembly is a type safety violation.
-    if (!result->IsAssembly())
-    {
-        ThrowHR(COR_E_ASSEMBLYEXPECTED);
-    }
-
     // Cache result in all cases, since found pPEAssembly could be from a different AssemblyRef than pIdentity
     if (pIdentity == NULL)
     {
@@ -2917,28 +2889,20 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity,
     RETURN result;
 } // AppDomain::LoadDomainAssembly
 
-
-struct LoadFileArgs
+DomainAssembly *AppDomain::LoadDomainAssembly(FileLoadLock *pLock, FileLoadLevel targetLevel)
 {
-    FileLoadLock *pLock;
-    FileLoadLevel targetLevel;
-    DomainFile *result;
-};
-
-DomainFile *AppDomain::LoadDomainFile(FileLoadLock *pLock, FileLoadLevel targetLevel)
-{
-    CONTRACT(DomainFile *)
+    CONTRACT(DomainAssembly *)
     {
         STANDARD_VM_CHECK;
         PRECONDITION(CheckPointer(pLock));
-        PRECONDITION(pLock->GetDomainFile()->GetAppDomain() == this);
+        PRECONDITION(pLock->GetDomainAssembly()->GetAppDomain() == this);
         POSTCONDITION(RETVAL->GetLoadLevel() >= GetThreadFileLoadLevel()
                       || RETVAL->GetLoadLevel() >= targetLevel);
         POSTCONDITION(RETVAL->CheckNoError(targetLevel));
     }
     CONTRACT_END;
 
-    DomainFile *pFile = pLock->GetDomainFile();
+    DomainAssembly *pFile = pLock->GetDomainAssembly();
 
     // Make sure we release the lock on exit
     FileLoadLockRefHolder lockRef(pLock);
@@ -3033,7 +2997,7 @@ DomainFile *AppDomain::LoadDomainFile(FileLoadLock *pLock, FileLoadLevel targetL
     // lower level.  In such a case, we throw an exception which transiently fails the current
     // load, since it is likely we have not satisfied the caller.
     // (An alternate, and possibly preferable, strategy here would be for all callers to explicitly
-    // identify the minimum load level acceptable via CheckLoadDomainFile and throw from there.)
+    // specify the minimum load level acceptable and throw if not reached.)
 
     pFile->RequireLoadLevel((FileLoadLevel)(immediateTargetLevel-1));
 
@@ -3041,7 +3005,7 @@ DomainFile *AppDomain::LoadDomainFile(FileLoadLock *pLock, FileLoadLevel targetL
     RETURN pFile;
 }
 
-void AppDomain::TryIncrementalLoad(DomainFile *pFile, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder)
+void AppDomain::TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder)
 {
     STANDARD_VM_CONTRACT;
 
@@ -3055,7 +3019,7 @@ void AppDomain::TryIncrementalLoad(DomainFile *pFile, FileLoadLevel workLevel, F
 
         // Special case: for LoadLibrary, we cannot hold the lock during the
         // actual LoadLibrary call, because we might get a callback from _CorDllMain on any
-        // other thread.  (Note that this requires DomainFile's LoadLibrary to be independently threadsafe.)
+        // other thread.  (Note that this requires DomainAssembly's LoadLibrary to be independently threadsafe.)
 
         if (workLevel == FILE_LOAD_LOADLIBRARY)
         {
@@ -3139,7 +3103,7 @@ CHECK AppDomain::CheckValidModule(Module * pModule)
     }
     CONTRACTL_END;
 
-    if (pModule->GetDomainFile() != NULL)
+    if (pModule->GetDomainAssembly() != NULL)
         CHECK_OK;
 
     CHECK_OK;
@@ -3826,7 +3790,7 @@ PEAssembly *AppDomain::TryResolveAssemblyUsingEvent(AssemblySpec *pSpec)
         Assembly *pAssembly = RaiseAssemblyResolveEvent(pSpec);
         if (pAssembly != nullptr)
         {
-            PEAssembly* pPEAssembly = pAssembly->GetManifestFile();
+            PEAssembly* pPEAssembly = pAssembly->GetPEAssembly();
             pPEAssembly->AddRef();
             result = pPEAssembly;
         }
@@ -4214,7 +4178,7 @@ DWORD DomainLocalModule::GetClassFlags(MethodTable* pMT, DWORD iClassIndex /*=(D
     } CONTRACTL_END;
 
     {
-        CONSISTENCY_CHECK(GetDomainFile()->GetModule() == pMT->GetModuleForStatics());
+        CONSISTENCY_CHECK(GetDomainAssembly()->GetModule() == pMT->GetModuleForStatics());
     }
 
     if (pMT->IsDynamicStatics())
@@ -4245,7 +4209,7 @@ void DomainLocalModule::SetClassInitialized(MethodTable* pMT)
     }
     CONTRACTL_END;
 
-    BaseDomain::DomainLocalBlockLockHolder lh(GetDomainFile()->GetAppDomain());
+    BaseDomain::DomainLocalBlockLockHolder lh(GetDomainAssembly()->GetAppDomain());
 
     _ASSERTE(!IsClassInitialized(pMT));
     _ASSERTE(!IsClassInitError(pMT));
@@ -4257,7 +4221,7 @@ void DomainLocalModule::SetClassInitError(MethodTable* pMT)
 {
     WRAPPER_NO_CONTRACT;
 
-    BaseDomain::DomainLocalBlockLockHolder lh(GetDomainFile()->GetAppDomain());
+    BaseDomain::DomainLocalBlockLockHolder lh(GetDomainAssembly()->GetAppDomain());
 
     SetClassFlags(pMT, ClassInitFlags::ERROR_FLAG);
 }
@@ -4267,9 +4231,9 @@ void DomainLocalModule::SetClassFlags(MethodTable* pMT, DWORD dwFlags)
     CONTRACTL {
         THROWS;
         GC_TRIGGERS;
-        PRECONDITION(GetDomainFile()->GetModule() == pMT->GetModuleForStatics());
+        PRECONDITION(GetDomainAssembly()->GetModule() == pMT->GetModuleForStatics());
         // Assumes BaseDomain::DomainLocalBlockLockHolder is taken
-        PRECONDITION(GetDomainFile()->GetAppDomain()->OwnDomainLocalBlockLock());
+        PRECONDITION(GetDomainAssembly()->GetAppDomain()->OwnDomainLocalBlockLock());
     } CONTRACTL_END;
 
     if (pMT->IsDynamicStatics())
@@ -4294,7 +4258,7 @@ void DomainLocalModule::EnsureDynamicClassIndex(DWORD dwID)
         MODE_ANY;
         INJECT_FAULT(COMPlusThrowOM(););
         // Assumes BaseDomain::DomainLocalBlockLockHolder is taken
-        PRECONDITION(GetDomainFile()->GetAppDomain()->OwnDomainLocalBlockLock());
+        PRECONDITION(GetDomainAssembly()->GetAppDomain()->OwnDomainLocalBlockLock());
     }
     CONTRACTL_END;
 
@@ -4312,7 +4276,7 @@ void DomainLocalModule::EnsureDynamicClassIndex(DWORD dwID)
 
     DynamicClassInfo* pNewDynamicClassTable;
     pNewDynamicClassTable = (DynamicClassInfo*)
-        (void*)GetDomainFile()->GetLoaderAllocator()->GetHighFrequencyHeap()->AllocMem(
+        (void*)GetDomainAssembly()->GetLoaderAllocator()->GetHighFrequencyHeap()->AllocMem(
             S_SIZE_T(sizeof(DynamicClassInfo)) * S_SIZE_T(aDynamicEntries));
 
     memcpy(pNewDynamicClassTable, m_pDynamicClassTable, sizeof(DynamicClassInfo) * m_aDynamicEntries);
@@ -4336,13 +4300,13 @@ void    DomainLocalModule::AllocateDynamicClass(MethodTable *pMT)
         THROWS;
         GC_TRIGGERS;
         // Assumes BaseDomain::DomainLocalBlockLockHolder is taken
-        PRECONDITION(GetDomainFile()->GetAppDomain()->OwnDomainLocalBlockLock());
+        PRECONDITION(GetDomainAssembly()->GetAppDomain()->OwnDomainLocalBlockLock());
     }
     CONTRACTL_END;
 
     _ASSERTE(!pMT->ContainsGenericVariables());
     _ASSERTE(!pMT->IsSharedByGenericInstantiations());
-    _ASSERTE(GetDomainFile()->GetModule() == pMT->GetModuleForStatics());
+    _ASSERTE(GetDomainAssembly()->GetModule() == pMT->GetModuleForStatics());
     _ASSERTE(pMT->IsDynamicStatics());
 
     DWORD dynamicEntryIDIndex = pMT->GetModuleDynamicEntryID();
@@ -4367,7 +4331,7 @@ void    DomainLocalModule::AllocateDynamicClass(MethodTable *pMT)
     {
         if (pDynamicStatics == NULL)
         {
-            LoaderHeap * pLoaderAllocator = GetDomainFile()->GetLoaderAllocator()->GetHighFrequencyHeap();
+            LoaderHeap * pLoaderAllocator = GetDomainAssembly()->GetLoaderAllocator()->GetHighFrequencyHeap();
 
             if (pMT->Collectible())
             {
@@ -4406,7 +4370,7 @@ void    DomainLocalModule::AllocateDynamicClass(MethodTable *pMT)
             else
 #endif
                 nongcStaticsArray = AllocatePrimitiveArray(ELEMENT_TYPE_U1, dwStaticBytes);
-            ((CollectibleDynamicEntry *)pDynamicStatics)->m_hNonGCStatics = GetDomainFile()->GetModule()->GetLoaderAllocator()->AllocateHandle(nongcStaticsArray);
+            ((CollectibleDynamicEntry *)pDynamicStatics)->m_hNonGCStatics = GetDomainAssembly()->GetModule()->GetLoaderAllocator()->AllocateHandle(nongcStaticsArray);
             GCPROTECT_END();
         }
         if (dwNumHandleStatics > 0)
@@ -4422,7 +4386,7 @@ void    DomainLocalModule::AllocateDynamicClass(MethodTable *pMT)
                 OBJECTREF gcStaticsArray = NULL;
                 GCPROTECT_BEGIN(gcStaticsArray);
                 gcStaticsArray = AllocateObjectArray(dwNumHandleStatics, g_pObjectClass);
-                ((CollectibleDynamicEntry *)pDynamicStatics)->m_hGCStatics = GetDomainFile()->GetModule()->GetLoaderAllocator()->AllocateHandle(gcStaticsArray);
+                ((CollectibleDynamicEntry *)pDynamicStatics)->m_hGCStatics = GetDomainAssembly()->GetModule()->GetLoaderAllocator()->AllocateHandle(gcStaticsArray);
                 GCPROTECT_END();
             }
         }
@@ -4447,7 +4411,7 @@ void DomainLocalModule::PopulateClass(MethodTable *pMT)
 
     if (!IsClassAllocated(pMT, iClassIndex))
     {
-        BaseDomain::DomainLocalBlockLockHolder lh(GetDomainFile()->GetAppDomain());
+        BaseDomain::DomainLocalBlockLockHolder lh(GetDomainAssembly()->GetAppDomain());
 
         if (!IsClassAllocated(pMT, iClassIndex))
         {
@@ -4902,7 +4866,7 @@ AppDomain::AssemblyIterator::Next_Unlocked(
             // Un-tenured collectible assemblies should not be returned. (This can only happen in a brief
             // window during collectible assembly creation. No thread should need to have a pointer
             // to the just allocated DomainAssembly at this stage.)
-            if (!pDomainAssembly->GetAssembly()->GetManifestModule()->IsTenured())
+            if (!pDomainAssembly->GetAssembly()->GetModule()->IsTenured())
             {
                 continue; // reject
             }
@@ -5185,9 +5149,9 @@ DomainLocalModule::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
     // sizeof(DomainLocalModule) == 0x28
     DAC_ENUM_DTHIS();
 
-    if (m_pDomainFile.IsValid())
+    if (m_pDomainAssembly.IsValid())
     {
-        m_pDomainFile->EnumMemoryRegions(flags);
+        m_pDomainAssembly->EnumMemoryRegions(flags);
     }
 
     if (m_pDynamicClassTable.Load().IsValid())
diff --git a/src/coreclr/vm/appdomain.hpp b/src/coreclr/vm/appdomain.hpp
index a369823a53937c..fbe728ff7e1c08 100644
--- a/src/coreclr/vm/appdomain.hpp
+++ b/src/coreclr/vm/appdomain.hpp
@@ -21,7 +21,7 @@
 #include "arraylist.h"
 #include "comreflectioncache.hpp"
 #include "comutilnative.h"
-#include "domainfile.h"
+#include "domainassembly.h"
 #include "fptrstubs.h"
 #include "gcheaputilities.h"
 #include "gchandleutilities.h"
@@ -201,18 +201,18 @@ struct DomainLocalModule
     static SIZE_T GetOffsetOfDataBlob() { return offsetof(DomainLocalModule, m_pDataBlob); }
     static SIZE_T GetOffsetOfGCStaticPointer() { return offsetof(DomainLocalModule, m_pGCStatics); }
 
-    inline DomainFile* GetDomainFile()
+    inline DomainAssembly* GetDomainAssembly()
     {
         LIMITED_METHOD_CONTRACT
         SUPPORTS_DAC;
-        return m_pDomainFile;
+        return m_pDomainAssembly;
     }
 
 #ifndef DACCESS_COMPILE
-    inline void        SetDomainFile(DomainFile* pDomainFile)
+    inline void        SetDomainAssembly(DomainAssembly* pDomainAssembly)
     {
         LIMITED_METHOD_CONTRACT
-        m_pDomainFile = pDomainFile;
+        m_pDomainAssembly = pDomainAssembly;
     }
 #endif
 
@@ -236,7 +236,7 @@ struct DomainLocalModule
 
         if (pMT->IsDynamicStatics())
         {
-            _ASSERTE(GetDomainFile()->GetModule() == pMT->GetModuleForStatics());
+            _ASSERTE(GetDomainAssembly()->GetModule() == pMT->GetModuleForStatics());
             return GetDynamicEntryGCStaticsBasePointer(pMT->GetModuleDynamicEntryID(), pMT->GetLoaderAllocator());
         }
         else
@@ -252,7 +252,7 @@ struct DomainLocalModule
 
         if (pMT->IsDynamicStatics())
         {
-            _ASSERTE(GetDomainFile()->GetModule() == pMT->GetModuleForStatics());
+            _ASSERTE(GetDomainAssembly()->GetModule() == pMT->GetModuleForStatics());
             return GetDynamicEntryNonGCStaticsBasePointer(pMT->GetModuleDynamicEntryID(), pMT->GetLoaderAllocator());
         }
         else
@@ -403,7 +403,7 @@ struct DomainLocalModule
     FORCEINLINE MethodTable * GetMethodTableFromClassDomainID(DWORD dwClassDomainID)
     {
         DWORD rid = (DWORD)(dwClassDomainID) + 1;
-        TypeHandle th = GetDomainFile()->GetModule()->LookupTypeDef(TokenFromRid(rid, mdtTypeDef));
+        TypeHandle th = GetDomainAssembly()->GetModule()->LookupTypeDef(TokenFromRid(rid, mdtTypeDef));
         _ASSERTE(!th.IsNull());
         MethodTable * pMT = th.AsMethodTable();
         PREFIX_ASSUME(pMT != NULL);
@@ -416,7 +416,7 @@ struct DomainLocalModule
     void SetClassFlags(MethodTable* pMT, DWORD dwFlags);
     DWORD GetClassFlags(MethodTable* pMT, DWORD iClassIndex);
 
-    PTR_DomainFile           m_pDomainFile;
+    PTR_DomainAssembly           m_pDomainAssembly;
     VolatilePtr<DynamicClassInfo, PTR_DynamicClassInfo> m_pDynamicClassTable;   // used for generics and reflection.emit in memory
     Volatile<SIZE_T>         m_aDynamicEntries;      // number of entries in dynamic table
     VolatilePtr<UMEntryThunk> m_pADThunkTable;
@@ -747,7 +747,7 @@ typedef PEFileListLock::Holder PEFileListLockHolder;
 
 // Loading infrastructure:
 //
-// a DomainFile is a file being loaded.  Files are loaded in layers to enable loading in the
+// a DomainAssembly is a file being loaded.  Files are loaded in layers to enable loading in the
 // presence of dependency loops.
 //
 // FileLoadLevel describes the various levels available.  These are implemented slightly
@@ -773,14 +773,14 @@ class FileLoadLock : public ListLockEntry
 {
 private:
     FileLoadLevel           m_level;
-    DomainFile              *m_pDomainFile;
+    DomainAssembly          *m_pDomainAssembly;
     HRESULT                 m_cachedHR;
 
 public:
-    static FileLoadLock *Create(PEFileListLock *pLock, PEAssembly *pPEAssembly, DomainFile *pDomainFile);
+    static FileLoadLock *Create(PEFileListLock *pLock, PEAssembly *pPEAssembly, DomainAssembly *pDomainAssembly);
 
     ~FileLoadLock();
-    DomainFile *GetDomainFile();
+    DomainAssembly *GetDomainAssembly();
     FileLoadLevel GetLoadLevel();
 
     // CanAcquire will return FALSE if Acquire will definitely not take the lock due
@@ -807,7 +807,7 @@ class FileLoadLock : public ListLockEntry
 
 private:
 
-    FileLoadLock(PEFileListLock *pLock, PEAssembly *pPEAssembly, DomainFile *pDomainFile);
+    FileLoadLock(PEFileListLock *pLock, PEAssembly *pPEAssembly, DomainAssembly *pDomainAssembly);
 
     static void HolderLeave(FileLoadLock *pThis);
 
@@ -1307,7 +1307,7 @@ enum AssemblyIterationFlags
                                         // (all m_level values)
     kIncludeAvailableToProfilers
                           = 0x00000020, // include assemblies available to profilers
-                                        // See comment at code:DomainFile::IsAvailableToProfilers
+                                        // See comment at code:DomainAssembly::IsAvailableToProfilers
 
     // Execution / introspection flags
     kIncludeExecution     = 0x00000004, // include assemblies that are loaded for execution only
@@ -1797,13 +1797,12 @@ class AppDomain : public BaseDomain
 
     CHECK CheckCanLoadTypes(Assembly *pAssembly);
     CHECK CheckCanExecuteManagedCode(MethodDesc* pMD);
-    CHECK CheckLoading(DomainFile *pFile, FileLoadLevel level);
+    CHECK CheckLoading(DomainAssembly *pFile, FileLoadLevel level);
 
-    FileLoadLevel GetDomainFileLoadLevel(DomainFile *pFile);
-    BOOL IsLoading(DomainFile *pFile, FileLoadLevel level);
+    BOOL IsLoading(DomainAssembly *pFile, FileLoadLevel level);
     static FileLoadLevel GetThreadFileLoadLevel();
 
-    void LoadDomainFile(DomainFile *pFile,
+    void LoadDomainAssembly(DomainAssembly *pFile,
                         FileLoadLevel targetLevel);
 
     enum FindAssemblyOptions
@@ -1839,10 +1838,10 @@ class AppDomain : public BaseDomain
     // private:
     void LoadSystemAssemblies();
 
-    DomainFile *LoadDomainFile(FileLoadLock *pLock,
+    DomainAssembly *LoadDomainAssembly(FileLoadLock *pLock,
                                FileLoadLevel targetLevel);
 
-    void TryIncrementalLoad(DomainFile *pFile, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder);
+    void TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder);
 
 #ifndef DACCESS_COMPILE // needs AssemblySpec
 
@@ -2453,7 +2452,7 @@ class SystemDomain : public BaseDomain
     {
         WRAPPER_NO_CONTRACT;
 
-        return SystemAssembly()->GetManifestModule();
+        return SystemAssembly()->GetModule();
     }
 
     static BOOL IsSystemLoaded()
@@ -2580,7 +2579,7 @@ class SystemDomain : public BaseDomain
 
         // Or, it might be the location of CoreLib
         if (System()->SystemAssembly() != NULL
-            && path.EqualsCaseInsensitive(System()->SystemAssembly()->GetManifestFile()->GetPath()))
+            && path.EqualsCaseInsensitive(System()->SystemAssembly()->GetPEAssembly()->GetPath()))
             return TRUE;
 
         return FALSE;
diff --git a/src/coreclr/vm/assembly.cpp b/src/coreclr/vm/assembly.cpp
index 6a2ff15250ddc8..83840af5b51387 100644
--- a/src/coreclr/vm/assembly.cpp
+++ b/src/coreclr/vm/assembly.cpp
@@ -123,14 +123,13 @@ Assembly::Assembly(BaseDomain *pDomain, PEAssembly* pPEAssembly, DebuggerAssembl
     m_pDomain(pDomain),
     m_pClassLoader(NULL),
     m_pEntryPoint(NULL),
-    m_pManifest(NULL),
-    m_pManifestFile(clr::SafeAddRef(pPEAssembly)),
+    m_pModule(NULL),
+    m_pPEAssembly(clr::SafeAddRef(pPEAssembly)),
     m_pFriendAssemblyDescriptor(NULL),
     m_isDynamic(false),
 #ifdef FEATURE_COLLECTIBLE_TYPES
     m_isCollectible(fIsCollectible),
 #endif
-    m_nextAvailableModuleIndex(1),
     m_pLoaderAllocator(NULL),
 #ifdef FEATURE_COMINTEROP
     m_pITypeLib(NULL),
@@ -186,7 +185,7 @@ void Assembly::Init(AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocat
     m_pClassLoader = new ClassLoader(this);
     m_pClassLoader->Init(pamTracker);
 
-    PEAssembly* pPEAssembly = GetManifestFile();
+    PEAssembly* pPEAssembly = GetPEAssembly();
 
     // "Module::Create" will initialize R2R support, if there is an R2R header.
     // make sure the PE is loaded or R2R will be disabled.
@@ -194,17 +193,15 @@ void Assembly::Init(AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocat
 
     if (pPEAssembly->IsDynamic())
         // manifest modules of dynamic assemblies are always transient
-        m_pManifest = ReflectionModule::Create(this, pPEAssembly, pamTracker, REFEMIT_MANIFEST_MODULE_NAME);
+        m_pModule = ReflectionModule::Create(this, pPEAssembly, pamTracker, REFEMIT_MANIFEST_MODULE_NAME);
     else
-        m_pManifest = Module::Create(this, mdFileNil, pPEAssembly, pamTracker);
+        m_pModule = Module::Create(this, mdFileNil, pPEAssembly, pamTracker);
 
     FastInterlockIncrement((LONG*)&g_cAssemblies);
 
-    PrepareModuleForAssembly(m_pManifest, pamTracker);
+    PrepareModuleForAssembly(m_pModule, pamTracker);
 
-    CacheManifestFiles();
-
-    if (!m_pManifest->IsReadyToRun())
+    if (!m_pModule->IsReadyToRun())
         CacheManifestExportedTypes(pamTracker);
 
     // We'll load the friend assembly information lazily.  For the ngen case we should avoid
@@ -228,7 +225,7 @@ void Assembly::Init(AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocat
         FAULT_FORBID();
         //Cannot fail after this point.
 
-        PublishModuleIntoAssembly(m_pManifest);
+        PublishModuleIntoAssembly(m_pModule);
 
         return;  // Explicit return to let you know you are NOT welcome to add code after the CANNOTTHROW/FAULT_FORBID expires
     }
@@ -249,9 +246,9 @@ Assembly::~Assembly()
     if (m_pFriendAssemblyDescriptor != NULL)
         m_pFriendAssemblyDescriptor->Release();
 
-    if (m_pManifestFile)
+    if (m_pPEAssembly)
     {
-        m_pManifestFile->Release();
+        m_pPEAssembly->Release();
     }
 
 #ifdef FEATURE_COMINTEROP
@@ -331,7 +328,7 @@ void Assembly::Terminate( BOOL signalProfiler )
 
 Assembly * Assembly::Create(
     BaseDomain *                 pDomain,
-    PEAssembly *                 pFile,
+    PEAssembly *                 pPEAssembly,
     DebuggerAssemblyControlFlags debuggerFlags,
     BOOL                         fIsCollectible,
     AllocMemTracker *            pamTracker,
@@ -339,7 +336,7 @@ Assembly * Assembly::Create(
 {
     STANDARD_VM_CONTRACT;
 
-    NewHolder<Assembly> pAssembly (new Assembly(pDomain, pFile, debuggerFlags, fIsCollectible));
+    NewHolder<Assembly> pAssembly (new Assembly(pDomain, pPEAssembly, debuggerFlags, fIsCollectible));
 
 #ifdef PROFILING_SUPPORTED
     {
@@ -513,7 +510,7 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, C
         IfFailThrow(pAssemblyEmit->DefineAssembly(publicKey, publicKey.GetSize(), ulHashAlgId,
                                                    name, &assemData, dwFlags,
                                                    &ma));
-        pPEAssembly = PEAssembly::Create(pCallerAssembly->GetManifestFile(), pAssemblyEmit);
+        pPEAssembly = PEAssembly::Create(pCallerAssembly->GetPEAssembly(), pAssemblyEmit);
 
         AssemblyBinder* pFallbackBinder = pBinder;
 
@@ -528,7 +525,7 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, C
             // and will have a fallback load context binder associated with it.
 
             // There is always a manifest file - wehther working with static or dynamic assemblies.
-            PEAssembly* pCallerAssemblyManifestFile = pCallerAssembly->GetManifestFile();
+            PEAssembly* pCallerAssemblyManifestFile = pCallerAssembly->GetPEAssembly();
             _ASSERTE(pCallerAssemblyManifestFile != NULL);
 
             if (!pCallerAssemblyManifestFile->IsDynamic())
@@ -622,7 +619,7 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, C
             // Assembly::Create will call SuppressRelease on the NewHolder that holds the LoaderAllocator when it transfers ownership
             pAssem = Assembly::Create(pDomain, pPEAssembly, pDomainAssembly->GetDebuggerInfoBits(), pLoaderAllocator->IsCollectible(), pamTracker, pLoaderAllocator);
 
-            ReflectionModule* pModule = (ReflectionModule*) pAssem->GetManifestModule();
+            ReflectionModule* pModule = (ReflectionModule*) pAssem->GetModule();
             pModule->SetCreatingAssembly( pCallerAssembly );
 
 
@@ -693,7 +690,7 @@ void Assembly::SetDomainAssembly(DomainAssembly *pDomainAssembly)
     }
     CONTRACTL_END;
 
-    GetManifestModule()->SetDomainFile(pDomainAssembly);
+    GetModule()->SetDomainAssembly(pDomainAssembly);
 
 } // Assembly::SetDomainAssembly
 
@@ -702,7 +699,7 @@ void Assembly::SetDomainAssembly(DomainAssembly *pDomainAssembly)
 DomainAssembly *Assembly::GetDomainAssembly()
 {
     LIMITED_METHOD_DAC_CONTRACT;
-    return GetManifestModule()->GetDomainAssembly();
+    return GetModule()->GetDomainAssembly();
 }
 
 PTR_LoaderHeap Assembly::GetLowFrequencyHeap()
@@ -795,9 +792,9 @@ Module *Assembly::FindModuleByExportedType(mdExportedType mdType,
     mdToken mdLinkRef;
     mdToken mdBinding;
 
-    IMDInternalImport *pManifestImport = GetManifestImport();
+    IMDInternalImport *pMDImport = GetMDImport();
 
-    IfFailThrow(pManifestImport->GetExportedTypeProps(
+    IfFailThrow(pMDImport->GetExportedTypeProps(
         mdType,
         NULL,
         NULL,
@@ -806,7 +803,7 @@ Module *Assembly::FindModuleByExportedType(mdExportedType mdType,
         NULL));         // dwflags
 
     // Don't trust the returned tokens.
-    if (!pManifestImport->IsValidToken(mdLinkRef))
+    if (!pMDImport->IsValidToken(mdLinkRef))
     {
         if (loadFlag != Loader::Load)
         {
@@ -831,27 +828,27 @@ Module *Assembly::FindModuleByExportedType(mdExportedType mdType,
 #ifndef DACCESS_COMPILE
                     // LoadAssembly never returns NULL
                     DomainAssembly * pDomainAssembly =
-                        GetManifestModule()->LoadAssembly(mdLinkRef);
+                        GetModule()->LoadAssembly(mdLinkRef);
                     PREFIX_ASSUME(pDomainAssembly != NULL);
 
-                    RETURN pDomainAssembly->GetCurrentModule();
+                    RETURN pDomainAssembly->GetModule();
 #else
                     _ASSERTE(!"DAC shouldn't attempt to trigger loading");
                     return NULL;
 #endif // !DACCESS_COMPILE
                 };
                 case Loader::DontLoad:
-                    pAssembly = GetManifestModule()->GetAssemblyIfLoaded(mdLinkRef);
+                    pAssembly = GetModule()->GetAssemblyIfLoaded(mdLinkRef);
                     break;
                 case Loader::SafeLookup:
-                    pAssembly = GetManifestModule()->LookupAssemblyRef(mdLinkRef);
+                    pAssembly = GetModule()->LookupAssemblyRef(mdLinkRef);
                     break;
                 default:
                     _ASSERTE(FALSE);
             }
 
             if (pAssembly)
-                RETURN pAssembly->GetManifestModule();
+                RETURN pAssembly->GetModule();
             else
                 RETURN NULL;
 
@@ -868,7 +865,7 @@ Module *Assembly::FindModuleByExportedType(mdExportedType mdType,
 
             // Note that we don't want to attempt a LoadModule if a GetModuleIfLoaded will
             // succeed, because it has a stronger contract.
-            Module *pModule = GetManifestModule()->GetModuleIfLoaded(mdLinkRef);
+            Module *pModule = GetModule()->GetModuleIfLoaded(mdLinkRef);
 #ifdef DACCESS_COMPILE
             return pModule;
 #else
@@ -881,17 +878,17 @@ Module *Assembly::FindModuleByExportedType(mdExportedType mdType,
             // We should never get here in the GC case - the above should have succeeded.
             CONSISTENCY_CHECK(!FORBIDGC_LOADER_USE_ENABLED());
 
-            DomainFile* pDomainModule = NULL;
+            DomainAssembly* pDomainModule = NULL;
             if (loadFlag == Loader::Load)
             {
-                pDomainModule = GetManifestModule()->LoadModule(::GetAppDomain(), mdLinkRef);
+                pDomainModule = GetModule()->LoadModule(::GetAppDomain(), mdLinkRef);
             }
 
             if (pDomainModule == NULL)
                 RETURN NULL;
             else
             {
-                pModule = pDomainModule->GetCurrentModule();
+                pModule = pDomainModule->GetModule();
                 if (pModule == NULL)
                 {
                     _ASSERTE(loadFlag!=Loader::Load);
@@ -1014,8 +1011,8 @@ Module * Assembly::FindModuleByTypeRef(
 #ifndef DACCESS_COMPILE
             if (loadFlag == Loader::Load)
             {
-                DomainFile* pActualDomainFile = pModule->LoadModule(::GetAppDomain(), tkType);
-                RETURN(pActualDomainFile->GetModule());
+                DomainAssembly* pActualDomainAssembly = pModule->LoadModule(::GetAppDomain(), tkType);
+                RETURN(pActualDomainAssembly->GetModule());
             }
             else
             {
@@ -1051,7 +1048,7 @@ Module * Assembly::FindModuleByTypeRef(
 
             if (pAssembly != NULL)
             {
-                RETURN pAssembly->m_pManifest;
+                RETURN pAssembly->m_pModule;
             }
 
 #ifdef DACCESS_COMPILE
@@ -1069,14 +1066,14 @@ Module * Assembly::FindModuleByTypeRef(
             if (pDomainAssembly == NULL)
                 RETURN NULL;
 
-            pAssembly = pDomainAssembly->GetCurrentAssembly();
+            pAssembly = pDomainAssembly->GetAssembly();
             if (pAssembly == NULL)
             {
                 RETURN NULL;
             }
             else
             {
-                RETURN pAssembly->m_pManifest;
+                RETURN pAssembly->m_pModule;
             }
 #endif //!DACCESS_COMPILE
         }
@@ -1111,9 +1108,9 @@ Module *Assembly::FindModuleByName(LPCSTR pszModuleName)
         ThrowHR(COR_E_UNAUTHORIZEDACCESS);
 
     if (this == SystemDomain::SystemAssembly())
-        RETURN m_pManifest->GetModuleIfLoaded(kFile);
+        RETURN m_pModule->GetModuleIfLoaded(kFile);
     else
-        RETURN m_pManifest->LoadModule(::GetAppDomain(), kFile)->GetModule();
+        RETURN m_pModule->LoadModule(::GetAppDomain(), kFile)->GetModule();
 }
 
 void Assembly::CacheManifestExportedTypes(AllocMemTracker *pamTracker)
@@ -1129,28 +1126,24 @@ void Assembly::CacheManifestExportedTypes(AllocMemTracker *pamTracker)
     // Prejitted assemblies are expected to have their table prebuilt.
     // If not, we do it here at load time (as if we would jit the assembly).
 
-    if (m_pManifest->IsPersistedObject(m_pManifest->m_pAvailableClasses))
+    if (m_pModule->IsPersistedObject(m_pModule->m_pAvailableClasses))
         RETURN;
 
     mdToken mdExportedType;
 
-    HENUMInternalHolder phEnum(GetManifestImport());
+    HENUMInternalHolder phEnum(GetMDImport());
     phEnum.EnumInit(mdtExportedType,
                     mdTokenNil);
 
     ClassLoader::AvailableClasses_LockHolder lh(m_pClassLoader);
 
-    for(int i = 0; GetManifestImport()->EnumNext(&phEnum, &mdExportedType); i++)
-        m_pClassLoader->AddExportedTypeHaveLock(GetManifestModule(),
+    for(int i = 0; GetMDImport()->EnumNext(&phEnum, &mdExportedType); i++)
+        m_pClassLoader->AddExportedTypeHaveLock(GetModule(),
                                                 mdExportedType,
                                                 pamTracker);
 
     RETURN;
 }
-void Assembly::CacheManifestFiles()
-{
-}
-
 
 //<TODO>@TODO: if module is not signed it needs to acquire the
 //permissions from the assembly.</TODO>
@@ -1183,7 +1176,7 @@ void Assembly::PrepareModuleForAssembly(Module* module, AllocMemTracker *pamTrac
          module->GetDebuggerInfoBits()));
 #endif // DEBUGGING_SUPPORTED
 
-    m_pManifest->EnsureFileCanBeStored(module->GetModuleRef());
+    m_pModule->EnsureFileCanBeStored(module->GetModuleRef());
 }
 
 // This is the final step of publishing a Module into an Assembly. This step cannot fail.
@@ -1197,7 +1190,7 @@ void Assembly::PublishModuleIntoAssembly(Module *module)
     }
     CONTRACTL_END
 
-    GetManifestModule()->EnsuredStoreFile(module->GetModuleRef(), module);
+    GetModule()->EnsuredStoreFile(module->GetModuleRef(), module);
     FastInterlockIncrement((LONG*)&m_pClassLoader->m_cUnhashedModules);
 }
 
@@ -1219,7 +1212,7 @@ void Assembly::CacheFriendAssemblyInfo()
 
     if (m_pFriendAssemblyDescriptor == NULL)
     {
-        ReleaseHolder<FriendAssemblyDescriptor> pFriendAssemblies = FriendAssemblyDescriptor::CreateFriendAssemblyDescriptor(this->GetManifestFile());
+        ReleaseHolder<FriendAssemblyDescriptor> pFriendAssemblies = FriendAssemblyDescriptor::CreateFriendAssemblyDescriptor(this->GetPEAssembly());
         _ASSERTE(pFriendAssemblies != NULL);
 
         CrstHolder friendDescriptorLock(&g_friendAssembliesCrst);
@@ -1254,7 +1247,7 @@ void Assembly::UpdateCachedFriendAssemblyInfo()
 
     while (true)
     {
-        ReleaseHolder<FriendAssemblyDescriptor> pFriendAssemblies = FriendAssemblyDescriptor::CreateFriendAssemblyDescriptor(this->GetManifestFile());
+        ReleaseHolder<FriendAssemblyDescriptor> pFriendAssemblies = FriendAssemblyDescriptor::CreateFriendAssemblyDescriptor(this->GetPEAssembly());
         FriendAssemblyDescriptor* pFriendAssemblyDescriptorNextLoop = NULL;
 
         {
@@ -1696,14 +1689,14 @@ MethodDesc* Assembly::GetEntryPoint()
     if (m_pEntryPoint)
         RETURN m_pEntryPoint;
 
-    mdToken mdEntry = m_pManifestFile->GetEntryPointToken();
+    mdToken mdEntry = m_pPEAssembly->GetEntryPointToken();
     if (IsNilToken(mdEntry))
         RETURN NULL;
 
     Module *pModule = NULL;
     switch(TypeFromToken(mdEntry)) {
     case mdtFile:
-        pModule = m_pManifest->LoadModule(::GetAppDomain(), mdEntry)->GetModule();
+        pModule = m_pModule->LoadModule(::GetAppDomain(), mdEntry)->GetModule();
 
         mdEntry = pModule->GetEntryPointToken();
         if ( (TypeFromToken(mdEntry) != mdtMethodDef) ||
@@ -1712,8 +1705,8 @@ MethodDesc* Assembly::GetEntryPoint()
         break;
 
     case mdtMethodDef:
-        if (m_pManifestFile->GetMDImport()->IsValidToken(mdEntry))
-            pModule = m_pManifest;
+        if (m_pPEAssembly->GetMDImport()->IsValidToken(mdEntry))
+            pModule = m_pModule;
         break;
     }
 
@@ -1871,7 +1864,7 @@ BOOL Assembly::IsInstrumentedHelper()
         return false;
 
     // We must have a native image in order to perform IBC instrumentation
-    if (!GetManifestFile()->IsReadyToRun())
+    if (!GetPEAssembly()->IsReadyToRun())
         return false;
 
     // @Consider using the full name instead of the short form
@@ -1998,7 +1991,7 @@ mdAssemblyRef Assembly::AddAssemblyRef(Assembly *refedAssembly, IMetaDataAssembl
     SafeComHolder<IMetaDataAssemblyEmit> emitHolder;
 
     AssemblySpec spec;
-    spec.InitializeSpec(refedAssembly->GetManifestFile());
+    spec.InitializeSpec(refedAssembly->GetPEAssembly());
 
     if (refedAssembly->IsCollectible())
     {
@@ -2056,7 +2049,7 @@ void Assembly::AddExportedType(mdExportedType cl)
     CONTRACTL_END
 
     AllocMemTracker amTracker;
-    m_pClassLoader->AddExportedTypeDontHaveLock(GetManifestModule(),
+    m_pClassLoader->AddExportedTypeDontHaveLock(GetModule(),
         cl,
         &amTracker);
     amTracker.SuppressRelease();
@@ -2235,13 +2228,13 @@ Assembly::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
     {
         m_pClassLoader->EnumMemoryRegions(flags);
     }
-    if (m_pManifest.IsValid())
+    if (m_pModule.IsValid())
     {
-        m_pManifest->EnumMemoryRegions(flags, true);
+        m_pModule->EnumMemoryRegions(flags, true);
     }
-    if (m_pManifestFile.IsValid())
+    if (m_pPEAssembly.IsValid())
     {
-        m_pManifestFile->EnumMemoryRegions(flags);
+        m_pPEAssembly->EnumMemoryRegions(flags);
     }
 }
 
diff --git a/src/coreclr/vm/assembly.hpp b/src/coreclr/vm/assembly.hpp
index f8de5c162e7524..8c72128f3e4f6c 100644
--- a/src/coreclr/vm/assembly.hpp
+++ b/src/coreclr/vm/assembly.hpp
@@ -56,16 +56,8 @@ struct CreateDynamicAssemblyArgs : CreateDynamicAssemblyArgsGC
     StackCrawlMark* stackMark;
 };
 
-// An assembly is the unit of deployment for managed code.  Typically Assemblies are one to one with files
-// (Modules), however this is not necessary, as an assembly can contain serveral files (typically you only
-// do this so that you can resource-only modules that are national language specific)
-//
-// Conceptually Assemblies are loaded into code:AppDomain
-//
-// So in general an assemly is a list of code:Module, where a code:Module is 1-1 with a DLL or EXE file.
-//
-// One of the modules the code:Assembly.m_pManifest is special in that it knows about all the other
-// modules in an assembly (often it is the only one).
+// An assembly is the unit of deployment for managed code.
+// Assemblies are one to one with files since coreclr does not support multimodule assemblies.
 //
 class Assembly
 {
@@ -88,7 +80,7 @@ class Assembly
     static Assembly *Create(BaseDomain *pDomain, PEAssembly *pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, BOOL fIsCollectible, AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocator);
     static void Initialize();
 
-    BOOL IsSystem() { WRAPPER_NO_CONTRACT; return m_pManifestFile->IsSystem(); }
+    BOOL IsSystem() { WRAPPER_NO_CONTRACT; return m_pPEAssembly->IsSystem(); }
 
     static Assembly *CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, CreateDynamicAssemblyArgs *args);
 
@@ -108,15 +100,7 @@ class Assembly
     void SetIsTenured()
     {
         WRAPPER_NO_CONTRACT;
-        m_pManifest->SetIsTenured();
-    }
-
-    // CAUTION: This should only be used as backout code if an assembly is unsuccessfully
-    //          added to the shared domain assembly map.
-    void UnsetIsTenured()
-    {
-        WRAPPER_NO_CONTRACT;
-        m_pManifest->UnsetIsTenured();
+        m_pModule->SetIsTenured();
     }
 #endif // DACCESS_COMPILE
 
@@ -130,72 +114,6 @@ class Assembly
         return m_pClassLoader;
     }
 
-    // ------------------------------------------------------------
-    // Modules
-    // ------------------------------------------------------------
-
-    class ModuleIterator
-    {
-        Module* m_pManifest;
-        DWORD m_i;
-
-      public:
-        // The preferred constructor.  If you use this, you don't have to
-        // call Start() yourself
-        ModuleIterator(Assembly *pAssembly)
-        {
-            WRAPPER_NO_CONTRACT;
-            Start(pAssembly);
-        }
-
-        // When you don't have the Assembly at contruction time, use this
-        // constructor, and explicitly call Start() to begin the iteration.
-        ModuleIterator()
-        {
-            LIMITED_METHOD_CONTRACT;
-            SUPPORTS_DAC;
-
-            m_pManifest = NULL;
-            m_i = (DWORD) -1;
-        }
-
-        void Start(Assembly * pAssembly)
-        {
-            LIMITED_METHOD_CONTRACT;
-            SUPPORTS_DAC;
-
-            m_pManifest = pAssembly->GetManifestModule();
-            m_i = (DWORD) -1;
-        }
-
-        BOOL Next()
-        {
-            LIMITED_METHOD_CONTRACT;
-            SUPPORTS_DAC;
-            while (++m_i <= m_pManifest->GetFileMax())
-            {
-                if (GetModule() != NULL)
-                    return TRUE;
-            }
-            return FALSE;
-        }
-
-        Module *GetModule()
-        {
-            LIMITED_METHOD_CONTRACT;
-            SUPPORTS_DAC;
-            return m_pManifest->LookupFile(TokenFromRid(m_i, mdtFile));
-        }
-    };
-
-    ModuleIterator IterateModules()
-    {
-        WRAPPER_NO_CONTRACT;
-        SUPPORTS_DAC;
-        return ModuleIterator(this);
-    }
-
-
     //****************************************************************************************
     //
     // Get the domain the assembly lives in.
@@ -231,75 +149,75 @@ class Assembly
     LPCWSTR GetDebugName()
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->GetDebugName();
+        return GetPEAssembly()->GetDebugName();
     }
 #endif
 
     LPCUTF8 GetSimpleName()
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->GetSimpleName();
+        return GetPEAssembly()->GetSimpleName();
     }
 
     BOOL IsStrongNamed()
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->IsStrongNamed();
+        return GetPEAssembly()->IsStrongNamed();
     }
 
     const void *GetPublicKey(DWORD *pcbPK)
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->GetPublicKey(pcbPK);
+        return GetPEAssembly()->GetPublicKey(pcbPK);
     }
 
     ULONG GetHashAlgId()
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->GetHashAlgId();
+        return GetPEAssembly()->GetHashAlgId();
     }
 
     HRESULT GetVersion(USHORT *pMajor, USHORT *pMinor, USHORT *pBuild, USHORT *pRevision)
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->GetVersion(pMajor, pMinor, pBuild, pRevision);
+        return GetPEAssembly()->GetVersion(pMajor, pMinor, pBuild, pRevision);
     }
 
     LPCUTF8 GetLocale()
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->GetLocale();
+        return GetPEAssembly()->GetLocale();
     }
 
     DWORD GetFlags()
     {
         WRAPPER_NO_CONTRACT;
-        return GetManifestFile()->GetFlags();
+        return GetPEAssembly()->GetFlags();
     }
 
     PTR_LoaderHeap GetLowFrequencyHeap();
     PTR_LoaderHeap GetHighFrequencyHeap();
     PTR_LoaderHeap GetStubHeap();
 
-    PTR_Module GetManifestModule()
+    PTR_Module GetModule()
     {
         LIMITED_METHOD_CONTRACT;
         SUPPORTS_DAC;
-        return m_pManifest;
+        return m_pModule;
     }
 
-    PTR_PEAssembly GetManifestFile()
+    PTR_PEAssembly GetPEAssembly()
     {
         LIMITED_METHOD_CONTRACT;
         SUPPORTS_DAC;
-        return m_pManifestFile;
+        return m_pPEAssembly;
     }
 
-    IMDInternalImport* GetManifestImport()
+    IMDInternalImport* GetMDImport()
     {
         WRAPPER_NO_CONTRACT;
         SUPPORTS_DAC;
-        return m_pManifestFile->GetMDImport();
+        return m_pPEAssembly->GetMDImport();
     }
 
     HRESULT GetCustomAttribute(mdToken parentToken,
@@ -309,7 +227,7 @@ class Assembly
     {
         WRAPPER_NO_CONTRACT;
         SUPPORTS_DAC;
-        return GetManifestModule()->GetCustomAttribute(parentToken, attribute, ppData, pcbData);
+        return GetModule()->GetCustomAttribute(parentToken, attribute, ppData, pcbData);
     }
 
     mdAssembly GetManifestToken()
@@ -324,7 +242,7 @@ class Assembly
     {
         WRAPPER_NO_CONTRACT;
 
-        return m_pManifestFile->GetDisplayName(result, flags);
+        return m_pPEAssembly->GetDisplayName(result, flags);
     }
 #endif // DACCESS_COMPILE
 
@@ -332,7 +250,7 @@ class Assembly
     {
         WRAPPER_NO_CONTRACT;
 
-        return m_pManifestFile->GetCodeBase(result);
+        return m_pPEAssembly->GetCodeBase(result);
     }
 
     OBJECTREF GetExposedObject();
@@ -360,7 +278,7 @@ class Assembly
 
     ULONG HashIdentity()
     {
-        return GetManifestFile()->HashIdentity();
+        return GetPEAssembly()->HashIdentity();
     }
 
     //****************************************************************************************
@@ -408,8 +326,6 @@ class Assembly
     FORCEINLINE BOOL IsDynamic() { LIMITED_METHOD_CONTRACT; return m_isDynamic; }
     FORCEINLINE BOOL IsCollectible() { LIMITED_METHOD_DAC_CONTRACT; return m_isCollectible; }
 
-    DWORD GetNextModuleIndex() { LIMITED_METHOD_CONTRACT; return m_nextAvailableModuleIndex++; }
-
     void AddType(Module* pModule,
                  mdTypeDef cl);
     void AddExportedType(mdExportedType cl);
@@ -520,9 +436,9 @@ class Assembly
 
         int mask = INTEROP_ATTRIBUTE_UNSET;
 
-        if (GetManifestModule()->GetCustomAttribute(TokenFromRid(1, mdtAssembly), WellKnownAttribute::ImportedFromTypeLib, NULL, 0) == S_OK)
+        if (GetModule()->GetCustomAttribute(TokenFromRid(1, mdtAssembly), WellKnownAttribute::ImportedFromTypeLib, NULL, 0) == S_OK)
             mask |= INTEROP_ATTRIBUTE_IMPORTED_FROM_TYPELIB;
-        if (GetManifestModule()->GetCustomAttribute(TokenFromRid(1, mdtAssembly), WellKnownAttribute::PrimaryInteropAssembly, NULL, 0) == S_OK)
+        if (GetModule()->GetCustomAttribute(TokenFromRid(1, mdtAssembly), WellKnownAttribute::PrimaryInteropAssembly, NULL, 0) == S_OK)
             mask |= INTEROP_ATTRIBUTE_PRIMARY_INTEROP_ASSEMBLY;
 
         if (!IsDynamic())
@@ -540,7 +456,6 @@ class Assembly
     //****************************************************************************************
 
     void CacheManifestExportedTypes(AllocMemTracker *pamTracker);
-    void CacheManifestFiles();
 
     void CacheFriendAssemblyInfo();
 #ifndef DACCESS_COMPILE
@@ -554,11 +469,9 @@ class Assembly
     PTR_BaseDomain        m_pDomain;        // Parent Domain
     PTR_ClassLoader       m_pClassLoader;   // Single Loader
 
-
-
     PTR_MethodDesc        m_pEntryPoint;    // Method containing the entry point
-    PTR_Module            m_pManifest;
-    PTR_PEAssembly        m_pManifestFile;
+    PTR_Module            m_pModule;
+    PTR_PEAssembly        m_pPEAssembly;
 
     FriendAssemblyDescriptor *m_pFriendAssemblyDescriptor;
 
@@ -566,7 +479,6 @@ class Assembly
 #ifdef FEATURE_COLLECTIBLE_TYPES
     BOOL                  m_isCollectible;
 #endif // FEATURE_COLLECTIBLE_TYPES
-    DWORD                 m_nextAvailableModuleIndex;
     PTR_LoaderAllocator   m_pLoaderAllocator;
 
 #ifdef FEATURE_COMINTEROP
@@ -590,8 +502,6 @@ class Assembly
 
 };
 
-typedef Assembly::ModuleIterator ModuleIterator;
-
 #ifndef DACCESS_COMPILE
 
 //---------------------------------------------------------------------------------------
@@ -673,7 +583,7 @@ class FriendAssemblyDescriptor
     static
     bool IsAssemblyOnList(Assembly *pAssembly, const ArrayList &alAssemblyNames)
     {
-        return IsAssemblyOnList(pAssembly->GetManifestFile(), alAssemblyNames);
+        return IsAssemblyOnList(pAssembly->GetPEAssembly(), alAssemblyNames);
     }
 
     static
diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp
index fcb7af91bb6bf5..dba5110590717c 100644
--- a/src/coreclr/vm/assemblynative.cpp
+++ b/src/coreclr/vm/assemblynative.cpp
@@ -105,7 +105,7 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(QCall::ObjectHandleOnStack
     {
         // If the requesting assembly has Fallback LoadContext binder available,
         // then set it up in the AssemblySpec.
-        PEAssembly *pRefAssemblyManifestFile = pRefAssembly->GetManifestFile();
+        PEAssembly *pRefAssemblyManifestFile = pRefAssembly->GetPEAssembly();
         spec.SetFallbackBinderForRequestingAssembly(pRefAssemblyManifestFile->GetFallbackBinder());
     }
 
@@ -269,7 +269,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssembl
     // we created above. We need pointer comparison instead of pe image equivalence
     // to avoid mixed binaries/PDB pairs of other images.
     // This applies to both Desktop CLR and CoreCLR, with or without fusion.
-    BOOL fIsSameAssembly = (pLoadedAssembly->GetManifestFile()->GetPEImage() == pILImage);
+    BOOL fIsSameAssembly = (pLoadedAssembly->GetPEAssembly()->GetPEImage() == pILImage);
 
     // Setting the PDB info is only applicable for our original assembly.
     // This applies to both Desktop CLR and CoreCLR, with or without fusion.
@@ -280,7 +280,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssembl
         if (ptrSymbolArray != NULL)
         {
             PBYTE pSymbolArray = reinterpret_cast<PBYTE>(ptrSymbolArray);
-            pLoadedAssembly->GetManifestModule()->SetSymbolBytes(pSymbolArray, (DWORD)cbSymbolArrayLength);
+            pLoadedAssembly->GetModule()->SetSymbolBytes(pSymbolArray, (DWORD)cbSymbolArrayLength);
         }
 #endif // DEBUGGING_SUPPORTED
     }
@@ -402,7 +402,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle
     mdToken mdImpl;
 
     Assembly * pAsm = pAssembly->GetAssembly();
-    Module *pManifestModule = pAsm->GetManifestModule();
+    Module *pManifestModule = pAsm->GetModule();
     IfFailThrow(pManifestModule->GetMDImport()->GetExportedTypeProps(mdtExternalType, &pszNameSpace, &pszClassName, &mdImpl, NULL, NULL));
     if (TypeFromToken(mdImpl) == mdtAssemblyRef)
     {
@@ -612,7 +612,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssem
     HENUMInternalHolder phEnum(pAssembly->GetMDImport());
     phEnum.EnumInit(mdtFile, mdTokenNil);
 
-    InlineSArray<DomainFile *, 8> modules;
+    InlineSArray<DomainAssembly *, 8> modules;
 
     modules.Append(pAssembly);
 
@@ -621,7 +621,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssem
     {
         if (fLoadIfNotFound)
         {
-            DomainFile* pModule = pAssembly->GetModule()->LoadModule(GetAppDomain(), mdFile);
+            DomainAssembly* pModule = pAssembly->GetModule()->LoadModule(GetAppDomain(), mdFile);
             modules.Append(pModule);
         }
     }
@@ -638,7 +638,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssem
 
         for(COUNT_T i = 0; i < modules.GetCount(); i++)
         {
-            DomainFile * pModule = modules[i];
+            DomainAssembly * pModule = modules[i];
 
             OBJECTREF o = pModule->GetExposedModuleObject();
             orModules->SetAt(i, o);
@@ -697,10 +697,10 @@ extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssemb
 
     LPCUTF8 pModuleName = NULL;
 
-    if SUCCEEDED(pAssembly->GetDomainAssembly()->GetModule()->GetScopeName(&pModuleName))
+    if SUCCEEDED(pAssembly->GetModule()->GetScopeName(&pModuleName))
     {
         if (::SString::_stricmp(pModuleName, szModuleName) == 0)
-            pModule = pAssembly->GetDomainAssembly()->GetModule();
+            pModule = pAssembly->GetModule();
     }
 
 
@@ -725,7 +725,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle
 
     Assembly * pAsm = pAssembly->GetAssembly();
 
-    IMDInternalImport *pImport = pAsm->GetManifestImport();
+    IMDInternalImport *pImport = pAsm->GetMDImport();
 
     {
         HENUMTypeDefInternalHolder phTDEnum(pImport);
@@ -753,7 +753,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle
 
             if (IsTdPublic(dwFlags))
             {
-                TypeHandle typeHnd = ClassLoader::LoadTypeDefThrowing(pAsm->GetManifestModule(), mdTD,
+                TypeHandle typeHnd = ClassLoader::LoadTypeDefThrowing(pAsm->GetModule(), mdTD,
                                                                       ClassLoader::ThrowIfNotFound,
                                                                       ClassLoader::PermitUninstDefOrRef);
                 types.Append(typeHnd);
@@ -801,7 +801,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle
                 IsTdPublic(dwFlags))
             {
                 NameHandle typeName(pszNameSpace, pszClassName);
-                typeName.SetTypeToken(pAsm->GetManifestModule(), mdCT);
+                typeName.SetTypeToken(pAsm->GetModule(), mdCT);
                 TypeHandle typeHnd = pAsm->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName);
 
                 types.Append(typeHnd);
@@ -845,7 +845,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle
 
     Assembly * pAsm = pAssembly->GetAssembly();
 
-    IMDInternalImport *pImport = pAsm->GetManifestImport();
+    IMDInternalImport *pImport = pAsm->GetMDImport();
 
     // enumerate the ExportedTypes table
     {
@@ -871,7 +871,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle
             if ((TypeFromToken(mdImpl) == mdtAssemblyRef) && (mdImpl != mdAssemblyRefNil))
             {
                 NameHandle typeName(pszNameSpace, pszClassName);
-                typeName.SetTypeToken(pAsm->GetManifestModule(), mdCT);
+                typeName.SetTypeToken(pAsm->GetModule(), mdCT);
                 TypeHandle typeHnd = pAsm->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName);
 
                 types.Append(typeHnd);
@@ -977,7 +977,7 @@ FCIMPL1(Object*, AssemblyNative::GetReferencedAssemblies, AssemblyBaseObject * p
 
     HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
 
-    IMDInternalImport *pImport = pAssembly->GetAssembly()->GetManifestImport();
+    IMDInternalImport *pImport = pAssembly->GetAssembly()->GetMDImport();
 
     MethodTable* pAsmNameClass = CoreLibBinder::GetClass(CLASS__ASSEMBLY_NAME);
 
@@ -1104,7 +1104,7 @@ FCIMPL1(ReflectModuleBaseObject *, AssemblyNative::GetInMemoryAssemblyModule, As
 
     DomainAssembly *pAssembly = refAssembly->GetDomainAssembly();
 
-    FC_RETURN_MODULE_OBJECT(pAssembly->GetCurrentModule(), refAssembly);
+    FC_RETURN_MODULE_OBJECT(pAssembly->GetModule(), refAssembly);
 }
 FCIMPLEND
 
@@ -1356,7 +1356,7 @@ extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate(
         {
             COMPlusThrow(kNotSupportedException, W("NotSupported_DebuggerAttached"));
         }
-        Module* pModule = assembly->GetDomainAssembly()->GetModule();
+        Module* pModule = assembly->GetModule();
         if (!pModule->IsEditAndContinueEnabled())
         {
             COMPlusThrow(kInvalidOperationException, W("InvalidOperation_AssemblyNotEditable"));
diff --git a/src/coreclr/vm/assemblyspec.cpp b/src/coreclr/vm/assemblyspec.cpp
index 5bdb2cbd65259e..cce0b240105d37 100644
--- a/src/coreclr/vm/assemblyspec.cpp
+++ b/src/coreclr/vm/assemblyspec.cpp
@@ -734,7 +734,7 @@ DomainAssembly *AssemblySpec::LoadDomainAssembly(FileLoadLevel targetLevel,
         BinderTracing::AssemblyBindOperation bindOperation(this);
         bindOperation.SetResult(pAssembly->GetPEAssembly(), true /*cached*/);
 
-        pDomain->LoadDomainFile(pAssembly, targetLevel);
+        pDomain->LoadDomainAssembly(pAssembly, targetLevel);
         RETURN pAssembly;
     }
 
diff --git a/src/coreclr/vm/assemblyspec.hpp b/src/coreclr/vm/assemblyspec.hpp
index 9f49c1d78cf751..8d2bd8045593d2 100644
--- a/src/coreclr/vm/assemblyspec.hpp
+++ b/src/coreclr/vm/assemblyspec.hpp
@@ -16,7 +16,7 @@
 #define _ASSEMBLYSPEC_H
 #include "hash.h"
 #include "assemblyspecbase.h"
-#include "domainfile.h"
+#include "domainassembly.h"
 #include "holder.h"
 
 class AppDomain;
diff --git a/src/coreclr/vm/ceeload.cpp b/src/coreclr/vm/ceeload.cpp
index 87876cded4d57f..c25b7aa19cc9d1 100644
--- a/src/coreclr/vm/ceeload.cpp
+++ b/src/coreclr/vm/ceeload.cpp
@@ -443,7 +443,6 @@ void Module::SetNativeMetadataAssemblyRefInCache(DWORD rid, PTR_Assembly pAssemb
 //
 // szName is only used by dynamic modules, see ReflectionModule::Initialize
 //
-//
 void Module::Initialize(AllocMemTracker *pamTracker, LPCWSTR szName)
 {
     CONTRACTL
@@ -464,14 +463,6 @@ void Module::Initialize(AllocMemTracker *pamTracker, LPCWSTR szName)
     m_DictionaryCrst.Init(CrstDomainLocalBlock);
 
     AllocateMaps();
-
-    if (IsSystem() ||
-        (strcmp(m_pSimpleName, "System") == 0) ||
-        (strcmp(m_pSimpleName, "System.Core") == 0))
-    {
-        FastInterlockOr(&m_dwPersistedFlags, LOW_LEVEL_SYSTEM_ASSEMBLY_BY_NAME);
-    }
-
     m_dwTransientFlags &= ~((DWORD)CLASSES_FREED);  // Set flag indicating LookupMaps are now in a consistent and destructable state
 
 #ifdef FEATURE_COLLECTIBLE_TYPES
@@ -1041,7 +1032,7 @@ BOOL Module::IsEditAndContinueCapable(Assembly *pAssembly, PEAssembly *pPEAssemb
 BOOL Module::IsManifest()
 {
     WRAPPER_NO_CONTRACT;
-    return dac_cast<TADDR>(GetAssembly()->GetManifestModule()) ==
+    return dac_cast<TADDR>(GetAssembly()->GetModule()) ==
            dac_cast<TADDR>(this);
 }
 
@@ -1049,14 +1040,7 @@ DomainAssembly* Module::GetDomainAssembly()
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
-    return dac_cast<PTR_DomainAssembly>(m_ModuleID->GetDomainFile());
-}
-
-DomainFile *Module::GetDomainFile()
-{
-    LIMITED_METHOD_DAC_CONTRACT;
-
-    return dac_cast<PTR_DomainFile>(m_ModuleID->GetDomainFile());
+    return dac_cast<PTR_DomainAssembly>(m_ModuleID->GetDomainAssembly());
 }
 
 #ifndef DACCESS_COMPILE
@@ -1629,9 +1613,7 @@ BOOL Module::IsNoStringInterning()
 
         HRESULT hr;
 
-        // This flag applies to assembly, but it is stored on module so it can be cached in ngen image
-        // Thus, we should ever need it for manifest module only.
-        IMDInternalImport *mdImport = GetAssembly()->GetManifestImport();
+        IMDInternalImport *mdImport = GetAssembly()->GetMDImport();
         _ASSERTE(mdImport);
 
         mdToken token;
@@ -1736,9 +1718,7 @@ BOOL Module::IsRuntimeWrapExceptions()
         HRESULT hr;
         BOOL fRuntimeWrapExceptions = FALSE;
 
-        // This flag applies to assembly, but it is stored on module so it can be cached in ngen image
-        // Thus, we should ever need it for manifest module only.
-        IMDInternalImport *mdImport = GetAssembly()->GetManifestImport();
+        IMDInternalImport *mdImport = GetAssembly()->GetMDImport();
 
         mdToken token;
         IfFailGo(mdImport->GetAssemblyFromScope(&token));
@@ -1792,7 +1772,7 @@ BOOL Module::IsRuntimeMarshallingEnabled()
 
     HRESULT hr;
 
-    IMDInternalImport *mdImport = GetAssembly()->GetManifestImport();
+    IMDInternalImport *mdImport = GetAssembly()->GetMDImport();
 
     mdToken token;
     if (SUCCEEDED(hr = mdImport->GetAssemblyFromScope(&token)))
@@ -1822,7 +1802,7 @@ BOOL Module::IsPreV4Assembly()
 
     if (!(m_dwPersistedFlags & COMPUTED_IS_PRE_V4_ASSEMBLY))
     {
-        IMDInternalImport *pImport = GetAssembly()->GetManifestImport();
+        IMDInternalImport *pImport = GetAssembly()->GetMDImport();
         _ASSERTE(pImport);
 
         BOOL fIsPreV4Assembly = FALSE;
@@ -2004,13 +1984,13 @@ void Module::AllocateStatics(AllocMemTracker *pamTracker)
     BuildStaticsOffsets(pamTracker);
 }
 
-void Module::SetDomainFile(DomainFile *pDomainFile)
+void Module::SetDomainAssembly(DomainAssembly *pDomainAssembly)
 {
     CONTRACTL
     {
         INSTANCE_CHECK;
-        PRECONDITION(CheckPointer(pDomainFile));
-        PRECONDITION(IsManifest() == pDomainFile->IsAssembly());
+        PRECONDITION(CheckPointer(pDomainAssembly));
+        PRECONDITION(IsManifest());
         THROWS;
         GC_TRIGGERS;
         MODE_ANY;
@@ -2030,7 +2010,7 @@ void Module::SetDomainFile(DomainFile *pDomainFile)
         }
         else
         {
-            pLoaderAllocator = pDomainFile->GetAppDomain()->GetLoaderAllocator();
+            pLoaderAllocator = pDomainAssembly->GetAppDomain()->GetLoaderAllocator();
         }
 
         SIZE_T size = GetDomainLocalModuleSize();
@@ -2070,7 +2050,7 @@ void Module::SetDomainFile(DomainFile *pDomainFile)
         m_ModuleID = pModuleData;
     }
 
-    m_ModuleID->SetDomainFile(pDomainFile);
+    m_ModuleID->SetDomainAssembly(pDomainAssembly);
 
     // Allocate static handles now.
     // NOTE: Bootstrapping issue with CoreLib - we will manually allocate later
@@ -2078,7 +2058,7 @@ void Module::SetDomainFile(DomainFile *pDomainFile)
     // as it is currently initialized through the DomainLocalModule::PopulateClass in MethodTable::CheckRunClassInitThrowing
     // (If we don't do this, it would allocate here unused regular static handles that will be overridden later)
     if (g_pPredefinedArrayTypes[ELEMENT_TYPE_OBJECT] != NULL && !GetAssembly()->IsCollectible())
-        AllocateRegularStaticHandles(pDomainFile->GetAppDomain());
+        AllocateRegularStaticHandles(pDomainAssembly->GetAppDomain());
 }
 
 OBJECTREF Module::GetExposedObject()
@@ -2093,7 +2073,7 @@ OBJECTREF Module::GetExposedObject()
     }
     CONTRACT_END;
 
-    RETURN GetDomainFile()->GetExposedModuleObject();
+    RETURN GetDomainAssembly()->GetExposedModuleObject();
 }
 
 //
@@ -3320,7 +3300,7 @@ Module::GetAssemblyIfLoaded(
                 }
 
                 if (pDomainAssembly && pDomainAssembly->IsLoaded())
-                    pAssembly = pDomainAssembly->GetCurrentAssembly(); // <NOTE> Do not use GetAssembly - that may force the completion of a load
+                    pAssembly = pDomainAssembly->GetAssembly();
 
                 // Only store in the rid map if working with the current AppDomain.
                 if (fCanUseRidMap && pAssembly)
@@ -3404,7 +3384,7 @@ DomainAssembly * Module::LoadAssembly(mdAssemblyRef kAssemblyRef)
     if (pAssembly != NULL)
     {
         pDomainAssembly = pAssembly->GetDomainAssembly();
-        ::GetAppDomain()->LoadDomainFile(pDomainAssembly, FILE_LOADED);
+        ::GetAppDomain()->LoadDomainAssembly(pDomainAssembly, FILE_LOADED);
 
         RETURN pDomainAssembly;
     }
@@ -3431,9 +3411,9 @@ DomainAssembly * Module::LoadAssembly(mdAssemblyRef kAssemblyRef)
             !pDomainAssembly->IsLoaded() ||                 // GetAssemblyIfLoaded will not find not-yet-loaded assemblies
             GetAssemblyIfLoaded(kAssemblyRef, NULL, FALSE, pDomainAssembly->GetPEAssembly()->GetHostAssembly()->GetBinder()) != NULL);     // GetAssemblyIfLoaded should find all remaining cases
 
-        if (pDomainAssembly->GetCurrentAssembly() != NULL)
+        if (pDomainAssembly->GetAssembly() != NULL)
         {
-            StoreAssemblyRef(kAssemblyRef, pDomainAssembly->GetCurrentAssembly());
+            StoreAssemblyRef(kAssemblyRef, pDomainAssembly->GetAssembly());
         }
     }
 
@@ -3474,7 +3454,7 @@ Module *Module::GetModuleIfLoaded(mdFile kFile)
         if (kFile == mdTokenNil)
             RETURN NULL;
 
-        RETURN GetAssembly()->GetManifestModule()->GetModuleIfLoaded(kFile);
+        RETURN GetAssembly()->GetModule()->GetModuleIfLoaded(kFile);
     }
 
     Module *pModule = LookupFile(kFile);
@@ -3483,7 +3463,7 @@ Module *Module::GetModuleIfLoaded(mdFile kFile)
         if (IsManifest())
         {
             if (kFile == mdFileNil)
-                pModule = GetAssembly()->GetManifestModule();
+                pModule = GetAssembly()->GetModule();
         }
         else
         {
@@ -3497,7 +3477,7 @@ Module *Module::GetModuleIfLoaded(mdFile kFile)
             {
                 if (kMatch == mdFileNil)
                 {
-                    pModule = pAssembly->GetManifestModule();
+                    pModule = pAssembly->GetModule();
                 }
                 else
                 {
@@ -3505,7 +3485,7 @@ Module *Module::GetModuleIfLoaded(mdFile kFile)
                 }
             }
             else
-            pModule = pAssembly->GetManifestModule()->LookupFile(kMatch);
+            pModule = pAssembly->GetModule()->LookupFile(kMatch);
         }
 
 #ifndef DACCESS_COMPILE
@@ -3521,9 +3501,9 @@ Module *Module::GetModuleIfLoaded(mdFile kFile)
 
 #ifndef DACCESS_COMPILE
 
-DomainFile *Module::LoadModule(AppDomain *pDomain, mdFile kFile)
+DomainAssembly *Module::LoadModule(AppDomain *pDomain, mdFile kFile)
 {
-    CONTRACT(DomainFile *)
+    CONTRACT(DomainAssembly *)
     {
         INSTANCE_CHECK;
         THROWS;
@@ -3543,7 +3523,7 @@ DomainFile *Module::LoadModule(AppDomain *pDomain, mdFile kFile)
     else
     {
         // This is mdtFile
-        IfFailThrow(GetAssembly()->GetManifestImport()->GetFileProps(kFile,
+        IfFailThrow(GetAssembly()->GetMDImport()->GetFileProps(kFile,
                                     &psModuleName,
                                     NULL,
                                     NULL,
@@ -3582,7 +3562,7 @@ PTR_Module Module::LookupModule(mdToken kFile)
         if (kFileLocal == mdTokenNil)
             COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
 
-        RETURN GetAssembly()->GetManifestModule()->LookupModule(kFileLocal);
+        RETURN GetAssembly()->GetModule()->LookupModule(kFileLocal);
     }
 
     PTR_Module pModule = LookupFile(kFile);
@@ -3593,12 +3573,12 @@ PTR_Module Module::LookupModule(mdToken kFile)
         mdFile kMatch = pAssembly->GetManifestFileToken(GetMDImport(), kFile);
         if (IsNilToken(kMatch)) {
             if (kMatch == mdFileNil)
-                pModule = pAssembly->GetManifestModule();
+                pModule = pAssembly->GetModule();
             else
             COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
         }
         else
-            pModule = pAssembly->GetManifestModule()->LookupFile(kMatch);
+            pModule = pAssembly->GetModule()->LookupFile(kMatch);
     }
     RETURN pModule;
 }
@@ -4067,7 +4047,7 @@ void Module::UpdateDynamicMetadataIfNeeded()
 
 #endif // DEBUGGING_SUPPORTED
 
-BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainFile * pDomainFile, int flags, BOOL attaching)
+BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainAssembly * pDomainAssembly, int flags, BOOL attaching)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -4078,7 +4058,7 @@ BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainFile * pDomainFile, in
     // Always capture metadata, even if no debugger is attached. If a debugger later attaches, it will use
     // this data.
     {
-        Module * pModule = pDomainFile->GetModule();
+        Module * pModule = pDomainAssembly->GetModule();
         pModule->UpdateDynamicMetadataIfNeeded();
     }
 
@@ -4099,7 +4079,7 @@ BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainFile * pDomainFile, in
                                       m_pPEAssembly->GetPath().GetCount(),
                                       GetAssembly(),
                                       pDomain,
-                                      pDomainFile,
+                                      pDomainAssembly,
                                       attaching);
 
         result = TRUE;
@@ -4595,7 +4575,7 @@ Module *Module::GetModuleFromIndex(DWORD ix)
         Assembly *pAssembly = this->LookupAssemblyRef(mdAssemblyRefToken);
         if (pAssembly)
         {
-            RETURN pAssembly->GetManifestModule();
+            RETURN pAssembly->GetModule();
         }
         else
         {
@@ -6478,11 +6458,7 @@ void Module::WriteAllModuleProfileData(bool cleanup)
 
             while (assemblyIterator.Next(pDomainAssembly.This()))
             {
-                DomainModuleIterator i = pDomainAssembly->IterateModules(kModIterIncludeLoaded);
-                while (i.Next())
-                {
-                    /*hr=*/i.GetModule()->WriteMethodProfileDataLogFile(cleanup);
-                }
+                pDomainAssembly->GetModule()->WriteMethodProfileDataLogFile(cleanup);
             }
         }
     }
@@ -7473,7 +7449,7 @@ VOID Module::EnsureActive()
         MODE_ANY;
     }
     CONTRACTL_END;
-    GetDomainFile()->EnsureActive();
+    GetDomainAssembly()->EnsureActive();
 }
 #endif // DACCESS_COMPILE
 
@@ -7492,13 +7468,13 @@ VOID Module::EnsureAllocated()
     }
     CONTRACTL_END;
 
-    GetDomainFile()->EnsureAllocated();
+    GetDomainAssembly()->EnsureAllocated();
 }
 
 VOID Module::EnsureLibraryLoaded()
 {
     STANDARD_VM_CONTRACT;
-    GetDomainFile()->EnsureLibraryLoaded();
+    GetDomainAssembly()->EnsureLibraryLoaded();
 }
 #endif // !DACCESS_COMPILE
 
@@ -7513,10 +7489,10 @@ CHECK Module::CheckActivated()
     CONTRACTL_END;
 
 #ifndef DACCESS_COMPILE
-    DomainFile *pDomainFile = GetDomainFile();
-    CHECK(pDomainFile != NULL);
-    PREFIX_ASSUME(pDomainFile != NULL);
-    CHECK(pDomainFile->CheckActivated());
+    DomainAssembly *pDomainAssembly = GetDomainAssembly();
+    CHECK(pDomainAssembly != NULL);
+    PREFIX_ASSUME(pDomainAssembly != NULL);
+    CHECK(pDomainAssembly->CheckActivated());
 #endif
     CHECK_OK;
 }
diff --git a/src/coreclr/vm/ceeload.h b/src/coreclr/vm/ceeload.h
index 2b9198b811732f..d9cd6742cb6c0e 100644
--- a/src/coreclr/vm/ceeload.h
+++ b/src/coreclr/vm/ceeload.h
@@ -832,8 +832,7 @@ class Module
         //If m_MethodDefToPropertyInfoMap has been generated
         COMPUTED_METHODDEF_TO_PROPERTYINFO_MAP = 0x00002000,
 
-        // Low level system assembly. Used by preferred zap module computation.
-        LOW_LEVEL_SYSTEM_ASSEMBLY_BY_NAME = 0x00004000,
+        // unused                   = 0x00004000,
 
         //If setting has been cached
         RUNTIME_MARSHALLING_ENABLED_IS_CACHED = 0x00008000,
@@ -1132,13 +1131,9 @@ class Module
     MethodTable *GetGlobalMethodTable();
     bool         NeedsGlobalMethodTable();
 
-    // This works for manifest modules too
-    DomainFile *GetDomainFile();
-
-    // Operates on assembly of module
     DomainAssembly *GetDomainAssembly();
 
-    void SetDomainFile(DomainFile *pDomainFile);
+    void SetDomainAssembly(DomainAssembly *pDomainAssembly);
 
     OBJECTREF GetExposedObject();
 
@@ -1195,14 +1190,6 @@ class Module
         LIMITED_METHOD_CONTRACT;
         FastInterlockOr(&m_dwTransientFlags, MODULE_IS_TENURED);
     }
-
-    // CAUTION: This should only be used as backout code if an assembly is unsuccessfully
-    //          added to the shared domain assembly map.
-    VOID UnsetIsTenured()
-    {
-        LIMITED_METHOD_CONTRACT;
-        FastInterlockAnd(&m_dwTransientFlags, ~MODULE_IS_TENURED);
-    }
 #endif // !DACCESS_COMPILE
 
 
@@ -1223,13 +1210,6 @@ class Module
     }
 #endif
 
-    BOOL IsLowLevelSystemAssemblyByName()
-    {
-        LIMITED_METHOD_CONTRACT;
-        // The flag is set during initialization, so we can skip the memory barrier
-        return m_dwPersistedFlags.LoadWithoutBarrier() & LOW_LEVEL_SYSTEM_ASSEMBLY_BY_NAME;
-    }
-
 #ifndef DACCESS_COMPILE
     VOID EnsureActive();
     VOID EnsureAllocated();
@@ -1436,7 +1416,7 @@ class Module
 
     DomainAssembly * LoadAssembly(mdAssemblyRef kAssemblyRef);
     Module *GetModuleIfLoaded(mdFile kFile);
-    DomainFile *LoadModule(AppDomain *pDomain, mdFile kFile);
+    DomainAssembly *LoadModule(AppDomain *pDomain, mdFile kFile);
     PTR_Module LookupModule(mdToken kFile); //wrapper over GetModuleIfLoaded, takes modulerefs as well
     DWORD GetAssemblyRefFlags(mdAssemblyRef tkAssemblyRef);
 
@@ -1719,7 +1699,7 @@ class Module
 public:
 
     // Debugger stuff
-    BOOL NotifyDebuggerLoad(AppDomain *pDomain, DomainFile * pDomainFile, int level, BOOL attaching);
+    BOOL NotifyDebuggerLoad(AppDomain *pDomain, DomainAssembly * pDomainAssembly, int level, BOOL attaching);
     void NotifyDebuggerUnload(AppDomain *pDomain);
 
     void SetDebuggerInfoBits(DebuggerAssemblyControlFlags newBits);
diff --git a/src/coreclr/vm/ceeload.inl b/src/coreclr/vm/ceeload.inl
index ca770297a4bc9c..fee8a8f4fcc33a 100644
--- a/src/coreclr/vm/ceeload.inl
+++ b/src/coreclr/vm/ceeload.inl
@@ -297,25 +297,25 @@ inline Assembly *Module::LookupAssemblyRef(mdAssemblyRef token)
 inline void Module::ForceStoreAssemblyRef(mdAssemblyRef token, Assembly *value)
 {
     WRAPPER_NO_CONTRACT; // THROWS/GC_NOTRIGGER/INJECT_FAULT()/MODE_ANY
-    _ASSERTE(value->GetManifestModule());
+    _ASSERTE(value->GetModule());
     _ASSERTE(TypeFromToken(token) == mdtAssemblyRef);
 
-    m_ManifestModuleReferencesMap.AddElement(this, RidFromToken(token), value->GetManifestModule());
+    m_ManifestModuleReferencesMap.AddElement(this, RidFromToken(token), value->GetModule());
 }
 
 inline void Module::StoreAssemblyRef(mdAssemblyRef token, Assembly *value)
 {
     WRAPPER_NO_CONTRACT;
-    _ASSERTE(value->GetManifestModule());
+    _ASSERTE(value->GetModule());
     _ASSERTE(TypeFromToken(token) == mdtAssemblyRef);
-    m_ManifestModuleReferencesMap.TrySetElement(RidFromToken(token), value->GetManifestModule());
+    m_ManifestModuleReferencesMap.TrySetElement(RidFromToken(token), value->GetModule());
 }
 
 inline mdAssemblyRef Module::FindAssemblyRef(Assembly *targetAssembly)
 {
     WRAPPER_NO_CONTRACT;
 
-    return m_ManifestModuleReferencesMap.Find(targetAssembly->GetManifestModule()) | mdtAssemblyRef;
+    return m_ManifestModuleReferencesMap.Find(targetAssembly->GetModule()) | mdtAssemblyRef;
 }
 
 #endif //DACCESS_COMPILE
diff --git a/src/coreclr/vm/classhash.cpp b/src/coreclr/vm/classhash.cpp
index 28c636f7c9aadd..7320f7bae72a75 100644
--- a/src/coreclr/vm/classhash.cpp
+++ b/src/coreclr/vm/classhash.cpp
@@ -267,7 +267,7 @@ VOID EEClassHashTable::ConstructKeyFromData(PTR_EEClassHashEntry pEntry, // IN
             mdToken mdtUncompressed = UncompressModuleAndClassDef(Data);
             if (TypeFromToken(mdtUncompressed) == mdtExportedType)
             {
-                IfFailThrow(GetModule()->GetClassLoader()->GetAssembly()->GetManifestImport()->GetExportedTypeProps(
+                IfFailThrow(GetModule()->GetClassLoader()->GetAssembly()->GetMDImport()->GetExportedTypeProps(
                     mdtUncompressed,
                     (LPCSTR *)&pszNameSpace,
                     (LPCSTR *)&pszName,
diff --git a/src/coreclr/vm/clsload.cpp b/src/coreclr/vm/clsload.cpp
index a2b0129e2dd71f..c1a5ffb86ecd90 100644
--- a/src/coreclr/vm/clsload.cpp
+++ b/src/coreclr/vm/clsload.cpp
@@ -563,7 +563,7 @@ BOOL ClassLoader::IsNested(Module *pModule, mdToken token, mdToken *mdEncloser)
                     (*mdEncloser != mdTypeRefNil));
 
         case mdtExportedType:
-            IfFailThrow(pModule->GetAssembly()->GetManifestImport()->GetExportedTypeProps(
+            IfFailThrow(pModule->GetAssembly()->GetMDImport()->GetExportedTypeProps(
                 token,
                 NULL,   // namespace
                 NULL,   // name
@@ -643,17 +643,11 @@ void ClassLoader::GetClassValue(NameHandleTable nhTable,
 #endif
 
     PTR_Assembly assembly = GetAssembly();
-    PREFIX_ASSUME(assembly != NULL);
-    ModuleIterator i = assembly->IterateModules();
+    Module * pCurrentClsModule = assembly->GetModule();
+    _ASSERTE(pCurrentClsModule != NULL);
 
-    while (i.Next())
+    if (!pLookInThisModuleOnly || (pCurrentClsModule == pLookInThisModuleOnly))
     {
-        Module * pCurrentClsModule = i.GetModule();
-        PREFIX_ASSUME(pCurrentClsModule != NULL);
-
-        if (pLookInThisModuleOnly && (pCurrentClsModule != pLookInThisModuleOnly))
-            continue;
-
 #ifdef FEATURE_READYTORUN
         if (nhTable == nhCaseSensitive && pCurrentClsModule->IsReadyToRun() && pCurrentClsModule->GetReadyToRunInfo()->HasHashtableOfTypes() &&
             pCurrentClsModule->GetAvailableClassHash() == NULL)
@@ -744,7 +738,7 @@ void ClassLoader::GetClassValue(NameHandleTable nhTable,
                                                                (pBucket = pTable->FindNextNestedClass(pName, pData, &sContext)) != NULL);
                         break;
                     case mdtExportedType:
-                        while ((!CompareNestedEntryWithExportedType(pNameModule->GetAssembly()->GetManifestImport(),
+                        while ((!CompareNestedEntryWithExportedType(pNameModule->GetAssembly()->GetMDImport(),
                                                                     mdEncloser,
                                                                     pCurrentClsModule->GetAvailableClassHash(),
                                                                     pBucket->GetEncloser())) &&
@@ -838,16 +832,11 @@ void ClassLoader::LazyPopulateCaseSensitiveHashTables()
     _ASSERT(m_cUnhashedModules > 0);
 
     AllocMemTracker amTracker;
-    ModuleIterator i = GetAssembly()->IterateModules();
 
-    // Create a case-sensitive hashtable for each module, and fill it with the module's typedef entries
-    while (i.Next())
+    // Create a case-sensitive hashtable for the module, and fill it with the module's typedef entries
+    Module *pModule = GetAssembly()->GetModule();
+    if (pModule->GetAvailableClassHash() == NULL)
     {
-        Module *pModule = i.GetModule();
-        PREFIX_ASSUME(pModule != NULL);
-        if (pModule->GetAvailableClassHash() != NULL)
-            continue;
-
         // Lazy construction of the case-sensitive hashtable of types is *only* a scenario for ReadyToRun images
         // (either images compiled with an old version of crossgen, or for case-insensitive type lookups in R2R modules)
         _ASSERT(pModule->IsReadyToRun());
@@ -858,14 +847,14 @@ void ClassLoader::LazyPopulateCaseSensitiveHashTables()
         PopulateAvailableClassHashTable(pModule, &amTracker);
     }
 
-    // Add exported types of the manifest module to the hashtable
-    IMDInternalImport * pManifestImport = GetAssembly()->GetManifestImport();
+    // Add exported types to the hashtable
+    IMDInternalImport * pManifestImport = GetAssembly()->GetMDImport();
     HENUMInternalHolder phEnum(pManifestImport);
     phEnum.EnumInit(mdtExportedType, mdTokenNil);
 
     mdToken mdExportedType;
     while (pManifestImport->EnumNext(&phEnum, &mdExportedType))
-        AddExportedTypeHaveLock(GetAssembly()->GetManifestModule(), mdExportedType, &amTracker);
+        AddExportedTypeHaveLock(GetAssembly()->GetModule(), mdExportedType, &amTracker);
 
     amTracker.SuppressRelease();
 }
@@ -882,7 +871,7 @@ void ClassLoader::LazyPopulateCaseInsensitiveHashTables()
     }
     CONTRACTL_END;
 
-    if (GetAssembly()->GetManifestModule()->GetAvailableClassHash() == NULL)
+    if (GetAssembly()->GetModule()->GetAvailableClassHash() == NULL)
     {
         // This is a R2R assembly, and a case insensitive type lookup was triggered.
         // Construct the case-sensitive table first, since the case-insensitive table
@@ -893,28 +882,23 @@ void ClassLoader::LazyPopulateCaseInsensitiveHashTables()
     // Add any unhashed modules into our hash tables, and try again.
 
     AllocMemTracker amTracker;
-    ModuleIterator i = GetAssembly()->IterateModules();
-
-    while (i.Next())
+    Module *pModule = GetAssembly()->GetModule();
+    if (pModule->GetAvailableClassCaseInsHash() == NULL)
     {
-        Module *pModule = i.GetModule();
-        if (pModule->GetAvailableClassCaseInsHash() == NULL)
-        {
-            EEClassHashTable *pNewClassCaseInsHash = pModule->GetAvailableClassHash()->MakeCaseInsensitiveTable(pModule, &amTracker);
+        EEClassHashTable *pNewClassCaseInsHash = pModule->GetAvailableClassHash()->MakeCaseInsensitiveTable(pModule, &amTracker);
 
-            LOG((LF_CLASSLOADER, LL_INFO10, "%s's classes being added to case insensitive hash table\n",
-                 pModule->GetSimpleName()));
+        LOG((LF_CLASSLOADER, LL_INFO10, "%s's classes being added to case insensitive hash table\n",
+                pModule->GetSimpleName()));
 
-            {
-                CANNOTTHROWCOMPLUSEXCEPTION();
-                FAULT_FORBID();
+        {
+            CANNOTTHROWCOMPLUSEXCEPTION();
+            FAULT_FORBID();
 
-                amTracker.SuppressRelease();
-                pModule->SetAvailableClassCaseInsHash(pNewClassCaseInsHash);
-                FastInterlockDecrement((LONG*)&m_cUnhashedModules);
+            amTracker.SuppressRelease();
+            pModule->SetAvailableClassCaseInsHash(pNewClassCaseInsHash);
+            FastInterlockDecrement((LONG*)&m_cUnhashedModules);
 
-                _ASSERT(m_cUnhashedModules >= 0);
-            }
+            _ASSERT(m_cUnhashedModules >= 0);
         }
     }
 }
@@ -1498,7 +1482,7 @@ ClassLoader::LoadTypeHandleThrowing(
                 if (typeHnd.IsNull() || !CompareNameHandleWithTypeHandleNoThrow(pName, typeHnd))
                 {
                     if (SUCCEEDED(pClsLdr->FindTypeDefByExportedType(
-                            pClsLdr->GetAssembly()->GetManifestImport(),
+                            pClsLdr->GetAssembly()->GetMDImport(),
                             FoundExportedType,
                             pFoundModule->GetMDImport(),
                             &FoundCl)))
@@ -1860,16 +1844,8 @@ void ClassLoader::FreeModules()
     CONTRACTL_END;
 
     Module *pManifest = NULL;
-    if (GetAssembly() && (NULL != (pManifest = GetAssembly()->GetManifestModule()))) {
-        // Unload the manifest last, since it contains the module list in its rid map
-        ModuleIterator i = GetAssembly()->IterateModules();
-        while (i.Next()) {
-            // Have the module free its various tables and some of the EEClass links
-            if (i.GetModule() != pManifest)
-                i.GetModule()->Destruct();
-        }
-
-        // Now do the manifest module.
+    if (GetAssembly() && (NULL != (pManifest = GetAssembly()->GetModule())))
+    {
         pManifest->Destruct();
     }
 
@@ -3267,15 +3243,6 @@ TypeHandle ClassLoader::LoadTypeHandleForTypeKey(TypeKey *pTypeKey,
     UINT32 typeLoad = ETW::TypeSystemLog::TypeLoadBegin();
 #endif
 
-    // When using domain neutral assemblies (and not eagerly propagating dependency loads),
-    // it's possible to get here without having injected the module into the current app domain.
-    // GetDomainFile will accomplish that.
-
-    if (!pTypeKey->IsConstructed())
-    {
-        pTypeKey->GetModule()->GetDomainFile();
-    }
-
     ClassLoadLevel currentLevel = typeHnd.IsNull() ? CLASS_LOAD_BEGIN : typeHnd.GetLoadLevel();
     ClassLoadLevel targetLevelUnderLock = targetLevel < CLASS_DEPENDENCIES_LOADED ? targetLevel : (ClassLoadLevel) (CLASS_DEPENDENCIES_LOADED-1);
     if (currentLevel < targetLevelUnderLock)
@@ -5159,12 +5126,7 @@ ClassLoader::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
 
     if (m_pAssembly.IsValid())
     {
-        ModuleIterator modIter = GetAssembly()->IterateModules();
-
-        while (modIter.Next())
-        {
-            modIter.GetModule()->EnumMemoryRegions(flags, true);
-        }
+        m_pAssembly->GetModule()->EnumMemoryRegions(flags, true);
     }
 }
 
diff --git a/src/coreclr/vm/codeversion.cpp b/src/coreclr/vm/codeversion.cpp
index 8fa82da46db6e2..d59e13d45d45d4 100644
--- a/src/coreclr/vm/codeversion.cpp
+++ b/src/coreclr/vm/codeversion.cpp
@@ -2036,18 +2036,15 @@ HRESULT CodeVersionManager::EnumerateDomainClosedMethodDescs(
     // these are the default flags which won't actually be used in shared mode other than
     // asserting they were specified with their default values
     AssemblyIterationFlags assemFlags = (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution);
-    ModuleIterationOption moduleFlags = (ModuleIterationOption)kModIterIncludeLoaded;
     if (pAppDomainToSearch != NULL)
     {
         assemFlags = (AssemblyIterationFlags)(kIncludeAvailableToProfilers | kIncludeExecution);
-        moduleFlags = (ModuleIterationOption)kModIterIncludeAvailableToProfilers;
     }
     LoadedMethodDescIterator it(
         pAppDomainToSearch,
         pModuleContainingMethodDef,
         methodDef,
-        assemFlags,
-        moduleFlags);
+        assemFlags);
     CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
     while (it.Next(pDomainAssembly.This()))
     {
diff --git a/src/coreclr/vm/comdynamic.cpp b/src/coreclr/vm/comdynamic.cpp
index 4996b53e2e48c8..99a6c788b1e4f4 100644
--- a/src/coreclr/vm/comdynamic.cpp
+++ b/src/coreclr/vm/comdynamic.cpp
@@ -900,12 +900,8 @@ void UpdateRuntimeStateForAssemblyCustomAttribute(Module* pModule, mdToken tkCus
         actualFlags = ((DWORD)pAssembly->GetDebuggerInfoBits() & mask) | flags;
         pAssembly->SetDebuggerInfoBits((DebuggerAssemblyControlFlags)actualFlags);
 
-        ModuleIterator i = pAssembly->IterateModules();
-        while (i.Next())
-        {
-            actualFlags = ((DWORD)(i.GetModule()->GetDebuggerInfoBits()) & mask) | flags;
-            i.GetModule()->SetDebuggerInfoBits((DebuggerAssemblyControlFlags)actualFlags);
-        }
+        actualFlags = ((DWORD)(pAssembly->GetModule()->GetDebuggerInfoBits()) & mask) | flags;
+        pAssembly->GetModule()->SetDebuggerInfoBits((DebuggerAssemblyControlFlags)actualFlags);
     }
 
     // InternalsVisibleTo and IgnoresAccessChecksTo attribute processing
diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp
index 0e1b0f9d444a95..cd2b5ab843456b 100644
--- a/src/coreclr/vm/commodule.cpp
+++ b/src/coreclr/vm/commodule.cpp
@@ -256,13 +256,13 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModul
     }
 
     SafeComHolderPreemp<IMetaDataAssemblyEmit> pAssemblyEmit;
-    IfFailThrow( pRefingAssembly->GetManifestModule()->GetEmitter()->QueryInterface(IID_IMetaDataAssemblyEmit, (void **) &pAssemblyEmit) );
+    IfFailThrow( pRefingAssembly->GetModule()->GetEmitter()->QueryInterface(IID_IMetaDataAssemblyEmit, (void **) &pAssemblyEmit) );
 
     CQuickBytes             qbNewSig;
     ULONG                   cbNewSig;
 
     IfFailThrow( pRefedModule->GetMDImport()->TranslateSigWithScope(
-        pRefedAssembly->GetManifestImport(),
+        pRefedAssembly->GetMDImport(),
         NULL, 0,        // hash value
         pvComSig,
         cbComSig,
@@ -335,7 +335,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleH
         Assembly * pRefingAssembly = pModule->GetAssembly();
 
         SafeComHolderPreemp<IMetaDataAssemblyEmit> pAssemblyEmit;
-        IfFailThrow( pRefingAssembly->GetManifestModule()->GetEmitter()->QueryInterface(IID_IMetaDataAssemblyEmit, (void **) &pAssemblyEmit) );
+        IfFailThrow( pRefingAssembly->GetModule()->GetEmitter()->QueryInterface(IID_IMetaDataAssemblyEmit, (void **) &pAssemblyEmit) );
 
         CQuickBytes     qbNewSig;
         ULONG           cbNewSig;
@@ -349,7 +349,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleH
         }
 
         IfFailThrow( pMeth->GetMDImport()->TranslateSigWithScope(
-            pRefedAssembly->GetManifestImport(),
+            pRefedAssembly->GetMDImport(),
             NULL, 0,        // hash blob value
             pvComSig,
             cbComSig,
@@ -421,14 +421,14 @@ extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::Mo
                 COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleBoundNonCollectible"));
         }
         SafeComHolderPreemp<IMetaDataAssemblyEmit> pAssemblyEmit;
-        IfFailThrow( pRefingAssembly->GetManifestModule()->GetEmitter()->QueryInterface(IID_IMetaDataAssemblyEmit, (void **) &pAssemblyEmit) );
+        IfFailThrow( pRefingAssembly->GetModule()->GetEmitter()->QueryInterface(IID_IMetaDataAssemblyEmit, (void **) &pAssemblyEmit) );
 
         // Translate the field signature this scope
         CQuickBytes     qbNewSig;
         ULONG           cbNewSig;
 
         IfFailThrow( pRefedMDImport->TranslateSigWithScope(
-        pRefedAssembly->GetManifestImport(),
+        pRefedAssembly->GetMDImport(),
         NULL, 0,            // hash value
         pvComSig,
         cbComSig,
diff --git a/src/coreclr/vm/common.h b/src/coreclr/vm/common.h
index bcd9af84555c68..c2fff3f9c9a961 100644
--- a/src/coreclr/vm/common.h
+++ b/src/coreclr/vm/common.h
@@ -120,8 +120,6 @@ typedef DPTR(class ComPlusCallMethodDesc) PTR_ComPlusCallMethodDesc;
 typedef VPTR(class DebugInterface)      PTR_DebugInterface;
 typedef DPTR(class Dictionary)          PTR_Dictionary;
 typedef VPTR(class DomainAssembly)      PTR_DomainAssembly;
-typedef VPTR(class DomainFile)          PTR_DomainFile;
-typedef VPTR(class DomainModule)        PTR_DomainModule;
 typedef DPTR(struct FailedAssembly)     PTR_FailedAssembly;
 typedef VPTR(class EditAndContinueModule) PTR_EditAndContinueModule;
 typedef DPTR(class EEClass)             PTR_EEClass;
@@ -429,7 +427,6 @@ extern DummyGlobalContract ___contract;
 #include "typehandle.inl"
 #include "object.inl"
 #include "clsload.inl"
-#include "domainfile.inl"
 #include "method.inl"
 #include "syncblk.inl"
 #include "threads.inl"
diff --git a/src/coreclr/vm/coreassemblyspec.cpp b/src/coreclr/vm/coreassemblyspec.cpp
index eaaddafdbe9c6b..2da6e14750d713 100644
--- a/src/coreclr/vm/coreassemblyspec.cpp
+++ b/src/coreclr/vm/coreassemblyspec.cpp
@@ -15,7 +15,7 @@
 #include "appdomain.inl"
 #include <peimage.h>
 #include "peimagelayout.inl"
-#include "domainfile.h"
+#include "domainassembly.h"
 #include "holder.h"
 #include "bundle.h"
 #include "strongnameinternal.h"
diff --git a/src/coreclr/vm/dbginterface.h b/src/coreclr/vm/dbginterface.h
index 51b2c3bf36358f..c9bc65c33fd287 100644
--- a/src/coreclr/vm/dbginterface.h
+++ b/src/coreclr/vm/dbginterface.h
@@ -68,7 +68,7 @@ class DebugInterface
                             DWORD        dwModuleName,    // number of characters in file name excludign null
                             Assembly *   pAssembly,       // the assembly the module belongs to
                             AppDomain *  pAppDomain,      // the AppDomain the module is being loaded into
-                            DomainFile * pDomainFile,
+                            DomainAssembly * pDomainAssembly,
                             BOOL         fAttaching) = 0; // true if this notification is due to a debugger
                                                           // being attached to the process
 
@@ -242,7 +242,7 @@ class DebugInterface
 
     // send a custom notification from the target to the RS. This will become an ICorDebugThread and
     // ICorDebugAppDomain on the RS.
-    virtual void SendCustomDebuggerNotification(Thread * pThread, DomainFile * pDomainFile, mdTypeDef classToken) = 0;
+    virtual void SendCustomDebuggerNotification(Thread * pThread, DomainAssembly * pDomainAssembly, mdTypeDef classToken) = 0;
 
     // Send an MDA notification. This ultimately translates to an ICorDebugMDA object on the Right-Side.
     virtual void SendMDANotification(
diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp
index 2ade537044abbe..566bb74d6d3eb9 100644
--- a/src/coreclr/vm/debugdebugger.cpp
+++ b/src/coreclr/vm/debugdebugger.cpp
@@ -827,11 +827,11 @@ FCIMPL1(void, DebugDebugger::CustomNotification, Object * dataUNSAFE)
         StrongHandleHolder objHandle = pAppDomain->CreateStrongHandle(pData);
         MethodTable * pMT = pData->GetGCSafeMethodTable();
         Module * pModule = pMT->GetModule();
-        DomainFile * pDomainFile = pModule->GetDomainFile();
+        DomainAssembly * pDomainAssembly = pModule->GetDomainAssembly();
         mdTypeDef classToken = pMT->GetCl();
 
         pThread->SetThreadCurrNotification(objHandle);
-        g_pDebugInterface->SendCustomDebuggerNotification(pThread, pDomainFile, classToken);
+        g_pDebugInterface->SendCustomDebuggerNotification(pThread, pDomainAssembly, classToken);
         pThread->ClearThreadCurrNotification();
 
         if (pThread->IsAbortRequested())
diff --git a/src/coreclr/vm/domainfile.cpp b/src/coreclr/vm/domainassembly.cpp
similarity index 80%
rename from src/coreclr/vm/domainfile.cpp
rename to src/coreclr/vm/domainassembly.cpp
index 22796801543b31..458f988280b02d 100644
--- a/src/coreclr/vm/domainfile.cpp
+++ b/src/coreclr/vm/domainassembly.cpp
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // --------------------------------------------------------------------------------
-// DomainFile.cpp
+// DomainAssembly.cpp
 //
 
 // --------------------------------------------------------------------------------
@@ -30,33 +30,42 @@
 #endif // FEATURE_PERFMAP
 
 #ifndef DACCESS_COMPILE
-DomainFile::DomainFile(AppDomain *pDomain, PEAssembly *pPEAssembly)
-  : m_pDomain(pDomain),
+DomainAssembly::DomainAssembly(AppDomain* pDomain, PEAssembly* pPEAssembly, LoaderAllocator* pLoaderAllocator) :
+    m_pAssembly(NULL),
+    m_pDomain(pDomain),
     m_pPEAssembly(pPEAssembly),
     m_pModule(NULL),
+    m_fCollectible(pLoaderAllocator->IsCollectible()),
+    m_NextDomainAssemblyInSameALC(NULL),
+    m_pLoaderAllocator(pLoaderAllocator),
     m_level(FILE_LOAD_CREATE),
-    m_pError(NULL),
-    m_notifyflags(NOT_NOTIFIED),
     m_loading(TRUE),
+    m_hExposedModuleObject(NULL),
+    m_hExposedAssemblyObject(NULL),
+    m_pError(NULL),
+    m_bDisableActivationCheck(FALSE),
+    m_fHostAssemblyPublished(FALSE),
     m_pDynamicMethodTable(NULL),
-    m_pUMThunkHash(NULL),
-    m_bDisableActivationCheck(FALSE)
+    m_debuggerFlags(DACF_NONE),
+    m_notifyflags(NOT_NOTIFIED),
+    m_fDebuggerUnloadStarted(FALSE)
 {
     CONTRACTL
     {
         CONSTRUCTOR_CHECK;
-        THROWS;  // From CreateHandle
-        GC_NOTRIGGER;
+        THROWS;             // ValidateForExecution
+        GC_TRIGGERS;        // ValidateForExecution
         MODE_ANY;
-        FORBID_FAULT;
     }
     CONTRACTL_END;
 
-    m_hExposedModuleObject = NULL;
     pPEAssembly->AddRef();
+    pPEAssembly->ValidateForExecution();
+
+    SetupDebuggingConfig();
 }
 
-DomainFile::~DomainFile()
+DomainAssembly::~DomainAssembly()
 {
     CONTRACTL
     {
@@ -70,36 +79,24 @@ DomainFile::~DomainFile()
     m_pPEAssembly->Release();
     if (m_pDynamicMethodTable)
         m_pDynamicMethodTable->Destroy();
-    delete m_pError;
-}
 
-#endif //!DACCESS_COMPILE
+    delete m_pError;
 
-LoaderAllocator * DomainFile::GetLoaderAllocator()
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-    Assembly *pAssembly = GetDomainAssembly()->GetAssembly();
-    if ((pAssembly != NULL) && (pAssembly->IsCollectible()))
+    if (m_fHostAssemblyPublished)
     {
-        return pAssembly->GetLoaderAllocator();
+        // Remove association first.
+        UnregisterFromHostAssembly();
     }
-    else
+
+    if (m_pAssembly != NULL)
     {
-        return this->GetAppDomain()->GetLoaderAllocator();
+        delete m_pAssembly;
     }
 }
 
-#ifndef DACCESS_COMPILE
-
 // Optimization intended for EnsureLoadLevel only
 #include <optsmallperfcritical.h>
-void DomainFile::EnsureLoadLevel(FileLoadLevel targetLevel)
+void DomainAssembly::EnsureLoadLevel(FileLoadLevel targetLevel)
 {
     CONTRACT_VOID
     {
@@ -112,7 +109,7 @@ void DomainFile::EnsureLoadLevel(FileLoadLevel targetLevel)
     TRIGGERSGC ();
     if (IsLoading())
     {
-        this->GetAppDomain()->LoadDomainFile(this, targetLevel);
+        this->GetAppDomain()->LoadDomainAssembly(this, targetLevel);
 
         // Enforce the loading requirement.  Note that we may have a deadlock in which case we
         // may be off by one which is OK.  (At this point if we are short of targetLevel we know
@@ -127,26 +124,7 @@ void DomainFile::EnsureLoadLevel(FileLoadLevel targetLevel)
 }
 #include <optdefault.h>
 
-void DomainFile::AttemptLoadLevel(FileLoadLevel targetLevel)
-{
-    CONTRACT_VOID
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACT_END;
-
-    if (IsLoading())
-        this->GetAppDomain()->LoadDomainFile(this, targetLevel);
-    else
-        ThrowIfError(targetLevel);
-
-    RETURN;
-}
-
-
-CHECK DomainFile::CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK)
+CHECK DomainAssembly::CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK)
 {
     CONTRACTL
     {
@@ -176,7 +154,7 @@ CHECK DomainFile::CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK)
 
 
 
-void DomainFile::RequireLoadLevel(FileLoadLevel targetLevel)
+void DomainAssembly::RequireLoadLevel(FileLoadLevel targetLevel)
 {
     CONTRACT_VOID
     {
@@ -196,7 +174,7 @@ void DomainFile::RequireLoadLevel(FileLoadLevel targetLevel)
 }
 
 
-void DomainFile::SetError(Exception *ex)
+void DomainAssembly::SetError(Exception *ex)
 {
     CONTRACT_VOID
     {
@@ -211,26 +189,26 @@ void DomainFile::SetError(Exception *ex)
 
     m_pError = new ExInfo(ex->DomainBoundClone());
 
-    GetCurrentModule()->NotifyEtwLoadFinished(ex->GetHR());
-
-    if (!IsProfilerNotified())
+    if (m_pModule)
     {
-        SetProfilerNotified();
+        m_pModule->NotifyEtwLoadFinished(ex->GetHR());
 
-#ifdef PROFILING_SUPPORTED
-        if (GetCurrentModule() != NULL)
+        if (!IsProfilerNotified())
         {
+            SetProfilerNotified();
+
+#ifdef PROFILING_SUPPORTED
             // Only send errors for non-shared assemblies; other assemblies might be successfully completed
             // in another app domain later.
-            GetCurrentModule()->NotifyProfilerLoadFinished(ex->GetHR());
-        }
+            m_pModule->NotifyProfilerLoadFinished(ex->GetHR());
 #endif
+        }
     }
 
     RETURN;
 }
 
-void DomainFile::ThrowIfError(FileLoadLevel targetLevel)
+void DomainAssembly::ThrowIfError(FileLoadLevel targetLevel)
 {
     CONTRACT_VOID
     {
@@ -250,7 +228,7 @@ void DomainFile::ThrowIfError(FileLoadLevel targetLevel)
     RETURN;
 }
 
-CHECK DomainFile::CheckNoError(FileLoadLevel targetLevel)
+CHECK DomainAssembly::CheckNoError(FileLoadLevel targetLevel)
 {
     LIMITED_METHOD_CONTRACT;
     CHECK(m_level >= targetLevel
@@ -259,7 +237,7 @@ CHECK DomainFile::CheckNoError(FileLoadLevel targetLevel)
     CHECK_OK;
 }
 
-CHECK DomainFile::CheckLoaded()
+CHECK DomainAssembly::CheckLoaded()
 {
     CONTRACTL
     {
@@ -270,7 +248,7 @@ CHECK DomainFile::CheckLoaded()
     }
     CONTRACTL_END;
 
-    CHECK_MSG(CheckNoError(FILE_LOADED), "DomainFile load resulted in an error");
+    CHECK_MSG(CheckNoError(FILE_LOADED), "DomainAssembly load resulted in an error");
 
     if (IsLoaded())
         CHECK_OK;
@@ -287,7 +265,7 @@ CHECK DomainFile::CheckLoaded()
     CHECK_OK;
 }
 
-CHECK DomainFile::CheckActivated()
+CHECK DomainAssembly::CheckActivated()
 {
     CONTRACTL
     {
@@ -298,7 +276,7 @@ CHECK DomainFile::CheckActivated()
     }
     CONTRACTL_END;
 
-    CHECK_MSG(CheckNoError(FILE_ACTIVE), "DomainFile load resulted in an error");
+    CHECK_MSG(CheckNoError(FILE_ACTIVE), "DomainAssembly load resulted in an error");
 
     if (IsActive())
         CHECK_OK;
@@ -311,7 +289,7 @@ CHECK DomainFile::CheckActivated()
         CHECK_OK;
 
     CHECK_MSG(GetPEAssembly()->IsLoaded(), "PEAssembly has not been loaded");
-    CHECK_MSG(IsLoaded(), "DomainFile has not been fully loaded");
+    CHECK_MSG(IsLoaded(), "DomainAssembly has not been fully loaded");
     CHECK_MSG(m_bDisableActivationCheck || CheckLoadLevel(FILE_ACTIVE), "File has not had execution verified");
 
     CHECK_OK;
@@ -319,20 +297,6 @@ CHECK DomainFile::CheckActivated()
 
 #endif //!DACCESS_COMPILE
 
-DomainAssembly *DomainFile::GetDomainAssembly()
-{
-    CONTRACTL
-    {
-        SUPPORTS_DAC;
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    _ASSERTE(IsAssembly());
-    return (DomainAssembly *) this;
-}
-
 // Return true iff the debugger should get notifications about this assembly.
 //
 // Notes:
@@ -358,7 +322,7 @@ BOOL DomainAssembly::IsVisibleToDebugger()
 // Returns managed representation of the module (Module or ModuleBuilder).
 // Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
 //
-OBJECTREF DomainFile::GetExposedModuleObject()
+OBJECTREF DomainAssembly::GetExposedModuleObject()
 {
     CONTRACTL
     {
@@ -423,9 +387,9 @@ OBJECTREF DomainFile::GetExposedModuleObject()
     }
 
     return pLoaderAllocator->GetHandleValue(m_hExposedModuleObject);
-} // DomainFile::GetExposedModuleObject
+}
 
-BOOL DomainFile::DoIncrementalLoad(FileLoadLevel level)
+BOOL DomainAssembly::DoIncrementalLoad(FileLoadLevel level)
 {
     STANDARD_VM_CONTRACT;
 
@@ -491,7 +455,7 @@ BOOL DomainFile::DoIncrementalLoad(FileLoadLevel level)
 
 #ifdef FEATURE_MULTICOREJIT
     {
-        Module * pModule = GetModule();
+        Module * pModule = m_pModule;
 
         if (pModule != NULL) // Should not triggle assert when module is NULL
         {
@@ -503,7 +467,7 @@ BOOL DomainFile::DoIncrementalLoad(FileLoadLevel level)
     return TRUE;
 }
 
-void DomainFile::PreLoadLibrary()
+void DomainAssembly::PreLoadLibrary()
 {
     CONTRACTL
     {
@@ -512,11 +476,9 @@ void DomainFile::PreLoadLibrary()
     }
     CONTRACTL_END;
 
-} // DomainFile::PreLoadLibrary
+} // DomainAssembly::PreLoadLibrary
 
-// Note that this is the sole loading function which must be called OUTSIDE THE LOCK, since
-// it will potentially involve the OS loader lock.
-void DomainFile::LoadLibrary()
+void DomainAssembly::LoadLibrary()
 {
     CONTRACTL
     {
@@ -527,7 +489,7 @@ void DomainFile::LoadLibrary()
 
 }
 
-void DomainFile::PostLoadLibrary()
+void DomainAssembly::PostLoadLibrary()
 {
     CONTRACTL
     {
@@ -557,46 +519,46 @@ void DomainFile::PostLoadLibrary()
     if (!IsProfilerNotified())
     {
         SetProfilerNotified();
-        GetCurrentModule()->NotifyProfilerLoadFinished(S_OK);
+        GetModule()->NotifyProfilerLoadFinished(S_OK);
     }
 
 #endif
 }
 
-void DomainFile::AddDependencies()
+void DomainAssembly::AddDependencies()
 {
     STANDARD_VM_CONTRACT;
 }
 
-void DomainFile::EagerFixups()
+void DomainAssembly::EagerFixups()
 {
     WRAPPER_NO_CONTRACT;
 
 #ifdef FEATURE_READYTORUN
-    if (GetCurrentModule()->IsReadyToRun())
+    if (GetModule()->IsReadyToRun())
     {
-        GetCurrentModule()->RunEagerFixups();
+        GetModule()->RunEagerFixups();
 
-        PEImageLayout * pLayout = GetCurrentModule()->GetReadyToRunInfo()->GetImage();
+        PEImageLayout * pLayout = GetModule()->GetReadyToRunInfo()->GetImage();
 
         TADDR base = dac_cast<TADDR>(pLayout->GetBase());
 
         ExecutionManager::AddCodeRange(base, base + (TADDR)pLayout->GetVirtualSize(),
                                         ExecutionManager::GetReadyToRunJitManager(),
                                          RangeSection::RANGE_SECTION_READYTORUN,
-                                         GetCurrentModule() /* (void *)pLayout */);
+                                         GetModule() /* (void *)pLayout */);
     }
 #endif // FEATURE_READYTORUN
 }
 
-void DomainFile::VtableFixups()
+void DomainAssembly::VtableFixups()
 {
     WRAPPER_NO_CONTRACT;
 
-    GetCurrentModule()->FixupVTables();
+    GetModule()->FixupVTables();
 }
 
-void DomainFile::FinishLoad()
+void DomainAssembly::FinishLoad()
 {
     CONTRACTL
     {
@@ -621,7 +583,7 @@ void DomainFile::FinishLoad()
 #endif
 }
 
-void DomainFile::Activate()
+void DomainAssembly::Activate()
 {
     CONTRACT_VOID
     {
@@ -631,24 +593,11 @@ void DomainFile::Activate()
     }
     CONTRACT_END;
 
-    // If we are a module, ensure we've activated the assembly first.
-
-    if (!IsAssembly())
-    {
-        GetDomainAssembly()->EnsureActive();
-    }
-    else
-    {
-        // We cannot execute any code in this assembly until we know what exception plan it is on.
-        // At the point of an exception's stack-crawl it is too late because we cannot tolerate a GC.
-        // See PossiblyUnwrapThrowable and its callers.
-        _ASSERTE(GetLoadedModule() == GetDomainAssembly()->GetLoadedAssembly()->GetManifestModule());
-        GetLoadedModule()->IsRuntimeWrapExceptions();
-    }
-
-    // Now activate any dependencies.
-    // This will typically cause reentrancy of course.
-
+    // We cannot execute any code in this assembly until we know what exception plan it is on.
+    // At the point of an exception's stack-crawl it is too late because we cannot tolerate a GC.
+    // See PossiblyUnwrapThrowable and its callers.
+    _ASSERTE(GetModule() == GetAssembly()->GetModule());
+    GetModule()->IsRuntimeWrapExceptions();
 
     //
     // Now call the module constructor.  Note that this might cause reentrancy;
@@ -669,84 +618,18 @@ void DomainFile::Activate()
     }
 #endif //_DEBUG
 
-
     RETURN;
 }
 
-//--------------------------------------------------------------------------------
-// DomainAssembly
-//--------------------------------------------------------------------------------
-
-DomainAssembly::DomainAssembly(AppDomain *pDomain, PEAssembly *pPEAssembly, LoaderAllocator *pLoaderAllocator)
-  : DomainFile(pDomain, pPEAssembly),
-    m_pAssembly(NULL),
-    m_debuggerFlags(DACF_NONE),
-    m_fDebuggerUnloadStarted(FALSE),
-    m_fCollectible(pLoaderAllocator->IsCollectible()),
-    m_fHostAssemblyPublished(false),
-    m_pLoaderAllocator(pLoaderAllocator),
-    m_NextDomainAssemblyInSameALC(NULL)
-{
-    CONTRACTL
-    {
-        CONSTRUCTOR_CHECK;
-        STANDARD_VM_CHECK;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    pPEAssembly->ValidateForExecution();
-
-    // !!! backout
-
-    m_hExposedAssemblyObject = NULL;
-
-    SetupDebuggingConfig();
-
-    // Add a Module iterator entry for this assembly.
-    IfFailThrow(m_Modules.Append(this));
-}
-
-DomainAssembly::~DomainAssembly()
-{
-    CONTRACTL
-    {
-        DESTRUCTOR_CHECK;
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    if (m_fHostAssemblyPublished)
-    {
-        // Remove association first.
-        UnregisterFromHostAssembly();
-    }
-
-    ModuleIterator i = IterateModules(kModIterIncludeLoading);
-    while (i.Next())
-    {
-        if (i.GetDomainFile() != this)
-            delete i.GetDomainFile();
-    }
-
-    if (m_pAssembly != NULL)
-    {
-        delete m_pAssembly;
-    }
-}
-
 void DomainAssembly::SetAssembly(Assembly* pAssembly)
 {
     STANDARD_VM_CONTRACT;
 
-    _ASSERTE(pAssembly->GetManifestModule()->GetPEAssembly()==m_pPEAssembly);
+    _ASSERTE(pAssembly->GetModule()->GetPEAssembly()==m_pPEAssembly);
     _ASSERTE(m_pAssembly == NULL);
 
     m_pAssembly = pAssembly;
-    m_pModule = pAssembly->GetManifestModule();
+    m_pModule = pAssembly->GetModule();
 
     pAssembly->SetDomainAssembly(this);
 }
@@ -841,7 +724,7 @@ OBJECTREF DomainAssembly::GetExposedAssemblyObject()
     }
 
     return pLoaderAllocator->GetHandleValue(m_hExposedAssemblyObject);
-} // DomainAssembly::GetExposedAssemblyObject
+}
 
 void DomainAssembly::Begin()
 {
@@ -917,8 +800,7 @@ void DomainAssembly::Allocate()
     }
 
     SetAssembly(pAssembly);
-
-} // DomainAssembly::Allocate
+}
 
 void DomainAssembly::DeliverAsyncEvents()
 {
@@ -933,10 +815,8 @@ void DomainAssembly::DeliverAsyncEvents()
 
     OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
     m_pDomain->RaiseLoadingAssemblyEvent(this);
-
 }
 
-
 void DomainAssembly::DeliverSyncEvents()
 {
     CONTRACTL
@@ -946,17 +826,8 @@ void DomainAssembly::DeliverSyncEvents()
     }
     CONTRACTL_END;
 
-    GetCurrentModule()->NotifyEtwLoadFinished(S_OK);
+    GetModule()->NotifyEtwLoadFinished(S_OK);
 
-    // We may be notified from inside the loader lock if we are delivering IJW events, so keep track.
-#ifdef PROFILING_SUPPORTED
-    if (!IsProfilerNotified())
-    {
-        SetProfilerNotified();
-        GetCurrentModule()->NotifyProfilerLoadFinished(S_OK);
-    }
-
-#endif
 #ifdef DEBUGGING_SUPPORTED
     GCX_COOP();
     if (!IsDebuggerNotified())
@@ -968,7 +839,7 @@ void DomainAssembly::DeliverSyncEvents()
 
     }
 #endif // DEBUGGING_SUPPORTED
-} // DomainAssembly::DeliverSyncEvents
+}
 
 /*
   // The enum for dwLocation from managed code:
@@ -1152,7 +1023,6 @@ BOOL DomainAssembly::NotifyDebuggerLoad(int flags, BOOL attaching)
     }
 
     // There is still work we need to do even when no debugger is attached.
-
     if (flags & ATTACH_ASSEMBLY_LOAD)
     {
         if (ShouldNotifyDebugger())
@@ -1162,24 +1032,18 @@ BOOL DomainAssembly::NotifyDebuggerLoad(int flags, BOOL attaching)
         result = TRUE;
     }
 
-    DomainModuleIterator i = IterateModules(kModIterIncludeLoading);
-    while (i.Next())
+    if(this->ShouldNotifyDebugger())
     {
-        DomainFile * pDomainFile = i.GetDomainFile();
-        if(pDomainFile->ShouldNotifyDebugger())
-        {
-            result = result ||
-                pDomainFile->GetModule()->NotifyDebuggerLoad(this->GetAppDomain(), pDomainFile, flags, attaching);
-        }
+        result = result ||
+            this->GetModule()->NotifyDebuggerLoad(this->GetAppDomain(), this, flags, attaching);
     }
+
     if( ShouldNotifyDebugger())
     {
            result|=m_pModule->NotifyDebuggerLoad(m_pDomain, this, ATTACH_MODULE_LOAD, attaching);
            SetDebuggerNotified();
     }
 
-
-
     return result;
 }
 
@@ -1195,29 +1059,22 @@ void DomainAssembly::NotifyDebuggerUnload()
 
     m_fDebuggerUnloadStarted = TRUE;
 
-    // Dispatch module unloads for all modules. Debugger is resilient in case we haven't dispatched
+    // Dispatch module unload for the module. Debugger is resilient in case we haven't dispatched
     // a previous load event (such as if debugger attached after the modules was loaded).
-    DomainModuleIterator i = IterateModules(kModIterIncludeLoading);
-    while (i.Next())
-    {
-            i.GetDomainFile()->GetModule()->NotifyDebuggerUnload(this->GetAppDomain());
-    }
+    this->GetModule()->NotifyDebuggerUnload(this->GetAppDomain());
 
     g_pDebugInterface->UnloadAssembly(this);
-
 }
 
 #endif // #ifndef DACCESS_COMPILE
 
 #ifdef DACCESS_COMPILE
 
-void
-DomainFile::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
+void DomainAssembly::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
 {
     SUPPORTS_DAC;
 
-    //sizeof(DomainFile) == 0x60
-    DAC_ENUM_VTHIS();
+    DAC_ENUM_DTHIS();
 
     // Modules are needed for all minidumps, but they are enumerated elsewhere
     // so we don't need to duplicate effort; thus we do noting with m_pModule.
@@ -1233,19 +1090,6 @@ DomainFile::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
     {
         m_pDomain->EnumMemoryRegions(flags, true);
     }
-}
-
-void
-DomainAssembly::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
-{
-    SUPPORTS_DAC;
-
-    //sizeof(DomainAssembly) == 0xe0
-    DAC_ENUM_VTHIS();
-    DomainFile::EnumMemoryRegions(flags);
-
-    // For minidumps without full memory, we need to always be able to iterate over m_Modules.
-    m_Modules.EnumMemoryRegions(flags);
 
     if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE)
     {
diff --git a/src/coreclr/vm/domainfile.h b/src/coreclr/vm/domainassembly.h
similarity index 59%
rename from src/coreclr/vm/domainfile.h
rename to src/coreclr/vm/domainassembly.h
index 917af193ceadea..268c49654253cd 100644
--- a/src/coreclr/vm/domainfile.h
+++ b/src/coreclr/vm/domainassembly.h
@@ -1,14 +1,14 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // --------------------------------------------------------------------------------
-// DomainFile.h
+// DomainAssembly.h
 //
 
 // --------------------------------------------------------------------------------
 
 
-#ifndef _DOMAINFILE_H_
-#define _DOMAINFILE_H_
+#ifndef _DOMAINASSEMBLY_H_
+#define _DOMAINASSEMBLY_H_
 
 // --------------------------------------------------------------------------------
 // Required headers
@@ -59,27 +59,23 @@ enum NotificationStatus
 };
 
 // --------------------------------------------------------------------------------
-// DomainFile represents a file loaded (or being loaded) into an app domain.  It
+// DomainAssembly represents an assembly loaded (or being loaded) into an app domain.  It
 // is guranteed to be unique per file per app domain.
 // --------------------------------------------------------------------------------
 
-class DomainFile
+class DomainAssembly final
 {
-    VPTR_BASE_VTABLE_CLASS(DomainFile);
-
-  public:
+public:
 
     // ------------------------------------------------------------
     // Public API
     // ------------------------------------------------------------
 
 #ifndef DACCESS_COMPILE
-    virtual ~DomainFile();
-    DomainFile() {LIMITED_METHOD_CONTRACT;};
+    ~DomainAssembly();
+    DomainAssembly() {LIMITED_METHOD_CONTRACT;};
 #endif
 
-    virtual LoaderAllocator *GetLoaderAllocator();
-
     PTR_AppDomain GetAppDomain()
     {
         LIMITED_METHOD_CONTRACT;
@@ -93,12 +89,41 @@ class DomainFile
         return PTR_PEAssembly(m_pPEAssembly);
     }
 
+    Assembly* GetAssembly()
+    {
+        LIMITED_METHOD_DAC_CONTRACT;
+        CONSISTENCY_CHECK(CheckLoaded());
+
+        return m_pAssembly;
+    }
+
+    Module* GetModule()
+    {
+        LIMITED_METHOD_CONTRACT;
+        CONSISTENCY_CHECK(CheckLoaded());
+
+        return m_pModule;
+    }
+
     IMDInternalImport *GetMDImport()
     {
         WRAPPER_NO_CONTRACT;
         return m_pPEAssembly->GetMDImport();
     }
 
+    OBJECTREF GetExposedAssemblyObjectIfExists()
+    {
+        LIMITED_METHOD_CONTRACT;
+
+        OBJECTREF objRet = NULL;
+        GET_LOADERHANDLE_VALUE_FAST(GetLoaderAllocator(), m_hExposedAssemblyObject, &objRet);
+        return objRet;
+    }
+
+    // Returns managed representation of the assembly (Assembly or AssemblyBuilder).
+    // Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
+    OBJECTREF GetExposedAssemblyObject();
+
     OBJECTREF GetExposedModuleObjectIfExists()
     {
         LIMITED_METHOD_CONTRACT;
@@ -130,9 +155,17 @@ class DomainFile
     }
 #endif
 
-    virtual BOOL IsAssembly() = 0;
+    BOOL IsCollectible()
+    {
+        LIMITED_METHOD_CONTRACT;
+        return m_fCollectible;
+    }
 
-    DomainAssembly *GetDomainAssembly();
+    ULONG HashIdentity()
+    {
+        WRAPPER_NO_CONTRACT;
+        return GetPEAssembly()->HashIdentity();
+    }
 
     // ------------------------------------------------------------
     // Loading state checks
@@ -202,7 +235,6 @@ class DomainFile
         return EnsureLoadLevel(FILE_LOAD_ALLOCATE);
     }
 
-
     void EnsureLibraryLoaded()
     {
         WRAPPER_NO_CONTRACT;
@@ -214,10 +246,6 @@ class DomainFile
     // is required for an operation.  Note that deadlocks are tolerated so the level may be one
     void EnsureLoadLevel(FileLoadLevel targetLevel) DAC_EMPTY();
 
-    // AttemptLoadLevel is a generic routine used to try to further load the file to a given level.
-    // No guarantee is made about the load level resulting however.
-    void AttemptLoadLevel(FileLoadLevel targetLevel) DAC_EMPTY();
-
     // CheckLoadLevel is an assert predicate used to verify the load level of an assembly.
     // deadlockOK indicates that the level is allowed to be one short if we are restricted
     // by loader reentrancy.
@@ -245,16 +273,12 @@ class DomainFile
     // ------------------------------------------------------------
 
 #ifndef DACCESS_COMPILE
-    BOOL Equals(DomainFile *pFile) { WRAPPER_NO_CONTRACT; return GetPEAssembly()->Equals(pFile->GetPEAssembly()); }
+    BOOL Equals(DomainAssembly *pAssembly) { WRAPPER_NO_CONTRACT; return GetPEAssembly()->Equals(pAssembly->GetPEAssembly()); }
     BOOL Equals(PEAssembly *pPEAssembly) { WRAPPER_NO_CONTRACT; return GetPEAssembly()->Equals(pPEAssembly); }
 #endif // DACCESS_COMPILE
 
-    Module* GetCurrentModule();
-    Module* GetLoadedModule();
-    Module* GetModule();
-
 #ifdef DACCESS_COMPILE
-    virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
+    void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
 #endif
 
 #ifndef DACCESS_COMPILE
@@ -262,7 +286,33 @@ class DomainFile
     DynamicMethodTable* GetDynamicMethodTable();
 #endif
 
- protected:
+    DomainAssembly* GetNextDomainAssemblyInSameALC()
+    {
+        return m_NextDomainAssemblyInSameALC;
+    }
+
+    void SetNextDomainAssemblyInSameALC(DomainAssembly* domainAssembly)
+    {
+        _ASSERTE(m_NextDomainAssemblyInSameALC == NULL);
+        m_NextDomainAssemblyInSameALC = domainAssembly;
+    }
+
+    LoaderAllocator* GetLoaderAllocator()
+    {
+        LIMITED_METHOD_CONTRACT;
+        return m_pLoaderAllocator;
+    }
+
+// ------------------------------------------------------------
+// Resource access
+// ------------------------------------------------------------
+
+    BOOL GetResource(LPCSTR szName, DWORD* cbResource,
+        PBYTE* pbInMemoryResource, DomainAssembly** pAssemblyRef,
+        LPCSTR* szFileName, DWORD* dwLocation,
+        BOOL fSkipRaiseResolveEvent);
+
+ private:
     // ------------------------------------------------------------
     // Loader API
     // ------------------------------------------------------------
@@ -272,59 +322,53 @@ class DomainFile
     friend class Module;
     friend class FileLoadLock;
 
-    DomainFile(AppDomain *pDomain, PEAssembly *pPEAssembly);
+    DomainAssembly(AppDomain* pDomain, PEAssembly* pPEAssembly, LoaderAllocator* pLoaderAllocator);
 
     BOOL DoIncrementalLoad(FileLoadLevel targetLevel);
     void ClearLoading() { LIMITED_METHOD_CONTRACT; m_loading = FALSE; }
     void SetLoadLevel(FileLoadLevel level) { LIMITED_METHOD_CONTRACT; m_level = level; }
 
 #ifndef DACCESS_COMPILE
-    virtual void Begin() = 0;
-    virtual void Allocate() = 0;
+    void Begin();
+    void Allocate();
     void AddDependencies();
     void PreLoadLibrary();
     void LoadLibrary();
-    void PostLoadLibrary();
+    void PostLoadLibrary(); 
     void EagerFixups();
     void VtableFixups();
-    virtual void DeliverSyncEvents() = 0;
-    virtual void DeliverAsyncEvents() = 0;
+    void DeliverSyncEvents();
+    void DeliverAsyncEvents();
     void FinishLoad();
     void Activate();
+
+    void RegisterWithHostAssembly();
+    void UnregisterFromHostAssembly();
 #endif
 
     // This should be used to permanently set the load to fail. Do not use with transient conditions
     void SetError(Exception *ex);
+    void SetAssembly(Assembly* pAssembly);
 
     void SetProfilerNotified() { LIMITED_METHOD_CONTRACT; m_notifyflags|= PROFILER_NOTIFIED; }
     void SetDebuggerNotified() { LIMITED_METHOD_CONTRACT; m_notifyflags|=DEBUGGER_NOTIFIED; }
     void SetShouldNotifyDebugger() { LIMITED_METHOD_CONTRACT; m_notifyflags|=DEBUGGER_NEEDNOTIFICATION; }
 
-    // ------------------------------------------------------------
-    // Instance data
-    // ------------------------------------------------------------
-
-    PTR_AppDomain               m_pDomain;
-    PTR_PEAssembly              m_pPEAssembly;
-    PTR_Module                  m_pModule;
-    FileLoadLevel               m_level;
-    LOADERHANDLE                m_hExposedModuleObject;
-
     class ExInfo
     {
         enum
         {
-           ExType_ClrEx,
-           ExType_HR
+            ExType_ClrEx,
+            ExType_HR
         }
         m_type;
         union
         {
-            Exception                   *m_pEx;
-            HRESULT                     m_hr;
+            Exception* m_pEx;
+            HRESULT    m_hr;
         };
 
-        public:
+    public:
         void Throw()
         {
             CONTRACTL
@@ -334,209 +378,35 @@ class DomainFile
                 MODE_ANY;
             }
             CONTRACTL_END;
-            if (m_type==ExType_ClrEx)
+            if (m_type == ExType_ClrEx)
             {
-                PAL_CPP_THROW(Exception *, m_pEx->DomainBoundClone());
+                PAL_CPP_THROW(Exception*, m_pEx->DomainBoundClone());
             }
-            if (m_type==ExType_HR)
+            if (m_type == ExType_HR)
                 ThrowHR(m_hr);
             _ASSERTE(!"Bad exception type");
             ThrowHR(E_UNEXPECTED);
         };
+
         ExInfo(Exception* pEx)
         {
             LIMITED_METHOD_CONTRACT;
-            m_type=ExType_ClrEx;
-            m_pEx=pEx;
+            m_type = ExType_ClrEx;
+            m_pEx = pEx;
         };
 
-        void ConvertToHResult()
-        {
-            LIMITED_METHOD_CONTRACT;
-            if(m_type==ExType_HR)
-                return;
-            _ASSERTE(m_type==ExType_ClrEx);
-            HRESULT hr=m_pEx->GetHR();
-            delete m_pEx;
-            m_hr=hr;
-            m_type=ExType_HR;
-        };
         ~ExInfo()
         {
             LIMITED_METHOD_CONTRACT;
-            if (m_type==ExType_ClrEx)
+            if (m_type == ExType_ClrEx)
                 delete m_pEx;
         }
-    }* m_pError;
-
-    void ReleaseManagedData()
-    {
-        if (m_pError)
-            m_pError->ConvertToHResult();
     };
 
-    DWORD                    m_notifyflags;
-    BOOL                        m_loading;
-    // m_pDynamicMethodTable is used by the light code generation to allow method
-    // generation on the fly. They are lazily created when/if a dynamic method is requested
-    // for this specific module
-    DynamicMethodTable          *m_pDynamicMethodTable;
-    class UMThunkHash *m_pUMThunkHash;
-    BOOL m_bDisableActivationCheck;
-};
-
-//---------------------------------------------------------------------------------------
-// One of these values is specified when requesting a module iterator to customize which
-// modules should appear in the enumeration
-enum ModuleIterationOption
-{
-    // include only modules that are already loaded (m_level >= FILE_LOAD_DELIVER_EVENTS)
-    kModIterIncludeLoaded                = 1,
-
-    // include all modules, even those that are still in the process of loading (all m_level values)
-    kModIterIncludeLoading               = 2,
-
-    // include only modules loaded just enough that profilers are notified of them.
-    // (m_level >= FILE_LOAD_LOADLIBRARY).  See comment at code:DomainFile::IsAvailableToProfilers
-    kModIterIncludeAvailableToProfilers  = 3,
-};
-
-// --------------------------------------------------------------------------------
-// DomainAssembly is a subclass of DomainFile which specifically represents a assembly.
-// --------------------------------------------------------------------------------
-
-class DomainAssembly : public DomainFile
-{
-    VPTR_VTABLE_CLASS(DomainAssembly, DomainFile);
-
 public:
-    // ------------------------------------------------------------
-    // Public API
-    // ------------------------------------------------------------
-
-    LoaderAllocator *GetLoaderAllocator()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_pLoaderAllocator;
-    }
-
-    void SetAssembly(Assembly* pAssembly);
-
-    BOOL IsAssembly()
-    {
-        LIMITED_METHOD_DAC_CONTRACT;
-        return TRUE;
-    }
-
-    OBJECTREF GetExposedAssemblyObjectIfExists()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        OBJECTREF objRet = NULL;
-        GET_LOADERHANDLE_VALUE_FAST(GetLoaderAllocator(), m_hExposedAssemblyObject, &objRet);
-        return objRet;
-    }
-
-    // Returns managed representation of the assembly (Assembly or AssemblyBuilder).
-    // Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
-    OBJECTREF GetExposedAssemblyObject();
-
-    Assembly* GetCurrentAssembly();
-    Assembly* GetLoadedAssembly();
-    Assembly* GetAssembly();
-
-#ifdef DACCESS_COMPILE
-    virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
-#endif
-
-    // ------------------------------------------------------------
-    // Modules
-    // ------------------------------------------------------------
-    class ModuleIterator
-    {
-        ArrayList::Iterator m_i;
-        ModuleIterationOption m_moduleIterationOption;
-
-      public:
-        BOOL Next()
-        {
-            WRAPPER_NO_CONTRACT;
-            while (m_i.Next())
-            {
-                if (m_i.GetElement() == NULL)
-                {
-                    continue;
-                }
-                if (GetDomainFile()->IsError())
-                {
-                    continue;
-                }
-                if (m_moduleIterationOption == kModIterIncludeLoading)
-                    return TRUE;
-                if ((m_moduleIterationOption == kModIterIncludeLoaded) &&
-                    GetDomainFile()->IsLoaded())
-                    return TRUE;
-                if ((m_moduleIterationOption == kModIterIncludeAvailableToProfilers) &&
-                    GetDomainFile()->IsAvailableToProfilers())
-                    return TRUE;
-            }
-            return FALSE;
-        }
-        Module *GetModule()
-        {
-            WRAPPER_NO_CONTRACT;
-            return GetDomainFile()->GetModule();
-        }
-        Module  *GetLoadedModule()
-        {
-            WRAPPER_NO_CONTRACT;
-            return GetDomainFile()->GetLoadedModule();
-        }
-        DomainFile *GetDomainFile()
-        {
-            WRAPPER_NO_CONTRACT;
-            return dac_cast<PTR_DomainFile>(m_i.GetElement());
-        }
-        SIZE_T GetIndex()
-        {
-            WRAPPER_NO_CONTRACT;
-            return m_i.GetIndex();
-        }
-
-      private:
-        friend class DomainAssembly;
-        // Cannot have constructor so this iterator can be used inside a union
-        static ModuleIterator Create(DomainAssembly * pDomainAssembly, ModuleIterationOption moduleIterationOption)
-        {
-            WRAPPER_NO_CONTRACT;
-            ModuleIterator i;
-
-            i.m_i = pDomainAssembly->m_Modules.Iterate();
-            i.m_moduleIterationOption = moduleIterationOption;
-
-            return i;
-        }
-    };
-    friend class ModuleIterator;
-
-    ModuleIterator IterateModules(ModuleIterationOption moduleIterationOption)
-    {
-        WRAPPER_NO_CONTRACT;
-        return ModuleIterator::Create(this, moduleIterationOption);
-    }
-
-    // ------------------------------------------------------------
-    // Resource access
-    // ------------------------------------------------------------
-
-    BOOL GetResource(LPCSTR szName, DWORD *cbResource,
-                     PBYTE *pbInMemoryResource, DomainAssembly** pAssemblyRef,
-                     LPCSTR *szFileName, DWORD *dwLocation,
-                     BOOL fSkipRaiseResolveEvent);
-
-    // ------------------------------------------------------------
-    // Debugger control API
-    // ------------------------------------------------------------
+// ------------------------------------------------------------
+// Debugger control API
+// ------------------------------------------------------------
 
     DebuggerAssemblyControlFlags GetDebuggerInfoBits(void)
     {
@@ -553,75 +423,46 @@ class DomainAssembly : public DomainFile
     void SetupDebuggingConfig(void);
     DWORD ComputeDebuggingConfig(void);
 
-    HRESULT GetDebuggingCustomAttributes(DWORD *pdwFlags);
+    HRESULT GetDebuggingCustomAttributes(DWORD* pdwFlags);
 
     BOOL IsVisibleToDebugger();
     BOOL NotifyDebuggerLoad(int flags, BOOL attaching);
     void NotifyDebuggerUnload();
 
-    inline BOOL IsCollectible();
-
-
- private:
-
+private:
     // ------------------------------------------------------------
-    // Loader API
+    // Instance data
     // ------------------------------------------------------------
 
-    friend class AppDomain;
-    friend class Assembly;
+    PTR_Assembly                m_pAssembly;
+    PTR_AppDomain               m_pDomain;
+    PTR_PEAssembly              m_pPEAssembly;
+    PTR_Module                  m_pModule;
 
-#ifndef DACCESS_COMPILE
-public:
-    ~DomainAssembly();
-private:
-    DomainAssembly(AppDomain *pDomain, PEAssembly *pPEAssembly, LoaderAllocator *pLoaderAllocator);
-#endif
+    BOOL                        m_fCollectible;
+    DomainAssembly*             m_NextDomainAssemblyInSameALC;
+    PTR_LoaderAllocator         m_pLoaderAllocator;
 
-    // ------------------------------------------------------------
-    // Internal routines
-    // ------------------------------------------------------------
+    FileLoadLevel               m_level;
+    BOOL                        m_loading;
 
-#ifndef DACCESS_COMPILE
-    void Begin();
-    void Allocate();
-    void DeliverSyncEvents();
-    void DeliverAsyncEvents();
-    void RegisterWithHostAssembly();
-    void UnregisterFromHostAssembly();
-#endif
+    LOADERHANDLE                m_hExposedModuleObject;
+    LOADERHANDLE                m_hExposedAssemblyObject;
 
- public:
-    ULONG HashIdentity();
+    ExInfo*                     m_pError;
 
-    // ------------------------------------------------------------
-    // Instance data
-    // ------------------------------------------------------------
+    BOOL                        m_bDisableActivationCheck;
+    BOOL                        m_fHostAssemblyPublished;
+
+    // m_pDynamicMethodTable is used by the light code generation to allow method
+    // generation on the fly. They are lazily created when/if a dynamic method is requested
+    // for this specific module
+    DynamicMethodTable*         m_pDynamicMethodTable;
 
-  private:
-    LOADERHANDLE                            m_hExposedAssemblyObject;
-    PTR_Assembly                            m_pAssembly;
-    DebuggerAssemblyControlFlags            m_debuggerFlags;
-    ArrayList                               m_Modules;
-    BOOL                                    m_fDebuggerUnloadStarted;
-    BOOL                                    m_fCollectible;
-    Volatile<bool>                          m_fHostAssemblyPublished;
-    PTR_LoaderAllocator                     m_pLoaderAllocator;
-    DomainAssembly*                         m_NextDomainAssemblyInSameALC;
-
-  public:
-      DomainAssembly* GetNextDomainAssemblyInSameALC()
-      {
-          return m_NextDomainAssemblyInSameALC;
-      }
-
-      void SetNextDomainAssemblyInSameALC(DomainAssembly* domainAssembly)
-      {
-          _ASSERTE(m_NextDomainAssemblyInSameALC == NULL);
-          m_NextDomainAssemblyInSameALC = domainAssembly;
-      }
-};
 
-typedef DomainAssembly::ModuleIterator DomainModuleIterator;
+    DebuggerAssemblyControlFlags    m_debuggerFlags;
+    DWORD                       m_notifyflags;
+    BOOL                        m_fDebuggerUnloadStarted;
+};
 
-#endif  // _DOMAINFILE_H_
+#endif  // _DOMAINASSEMBLY_H_
diff --git a/src/coreclr/vm/domainfile.inl b/src/coreclr/vm/domainfile.inl
deleted file mode 100644
index a87d9aaef13096..00000000000000
--- a/src/coreclr/vm/domainfile.inl
+++ /dev/null
@@ -1,72 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//
-
-inline Module* DomainFile::GetCurrentModule()
-{
-    LIMITED_METHOD_CONTRACT;
-    SUPPORTS_DAC;
-
-    return m_pModule;
-}
-
-inline Module* DomainFile::GetLoadedModule()
-{
-    LIMITED_METHOD_CONTRACT;
-    CONSISTENCY_CHECK(CheckLoaded());
-
-    return m_pModule;
-}
-
-inline Module* DomainFile::GetModule()
-{
-    LIMITED_METHOD_CONTRACT;
-    SUPPORTS_DAC;
-
-    {
-        // While executing the consistency check, we will take a lock.
-        // But since this is debug-only, we'll allow the lock violation so that
-        // CANNOT_TAKE_LOCK callers aren't penalized
-        CONTRACT_VIOLATION(TakesLockViolation);
-        CONSISTENCY_CHECK(CheckLoadLevel(FILE_LOAD_ALLOCATE));
-    }
-
-    return m_pModule;
-}
-
-inline Assembly* DomainAssembly::GetCurrentAssembly()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    return m_pAssembly;
-}
-
-inline Assembly* DomainAssembly::GetLoadedAssembly()
-{
-    LIMITED_METHOD_DAC_CONTRACT;
-    CONSISTENCY_CHECK(CheckLoaded());
-
-    return m_pAssembly;
-}
-
-inline Assembly* DomainAssembly::GetAssembly()
-{
-    LIMITED_METHOD_CONTRACT;
-
-    CONSISTENCY_CHECK(CheckLoadLevel(FILE_LOAD_ALLOCATE));
-    return m_pAssembly;
-}
-
-inline ULONG DomainAssembly::HashIdentity()
-{
-    WRAPPER_NO_CONTRACT;
-    return GetPEAssembly()->HashIdentity();
-}
-
-inline BOOL DomainAssembly::IsCollectible()
-{
-    LIMITED_METHOD_CONTRACT;
-    return m_fCollectible;
-}
-
diff --git a/src/coreclr/vm/dwbucketmanager.hpp b/src/coreclr/vm/dwbucketmanager.hpp
index 2524f706c7ef3f..6eb0e9438b5f32 100644
--- a/src/coreclr/vm/dwbucketmanager.hpp
+++ b/src/coreclr/vm/dwbucketmanager.hpp
@@ -650,7 +650,7 @@ void BaseBucketParamsManager::GetModuleVersion(_Out_writes_(maxLength) WCHAR* ta
         // if we failed to get a version and this isn't the manifest module then try that
         if (!gotFileVersion && !pModule->IsManifest())
         {
-            pModule = pModule->GetAssembly()->GetManifestModule();
+            pModule = pModule->GetAssembly()->GetModule();
             if (pModule)
                 gotFileVersion = GetFileVersionInfoForModule(pModule, major, minor, build, revision);
         }
@@ -701,7 +701,7 @@ void BaseBucketParamsManager::GetModuleTimeStamp(_Out_writes_(maxLength) WCHAR*
         {
             // We only store the IL timestamp in the native image for the
             // manifest module.  We should consider fixing this for Orcas.
-            PTR_PEAssembly pFile = pModule->GetAssembly()->GetManifestModule()->GetPEAssembly();
+            PTR_PEAssembly pFile = pModule->GetAssembly()->GetModule()->GetPEAssembly();
 
             // for dynamic modules use 0 as the time stamp
             ULONG ulTimeStamp = 0;
diff --git a/src/coreclr/vm/dynamicmethod.cpp b/src/coreclr/vm/dynamicmethod.cpp
index 35137855229e5a..a5a9ee44ba8ebd 100644
--- a/src/coreclr/vm/dynamicmethod.cpp
+++ b/src/coreclr/vm/dynamicmethod.cpp
@@ -20,7 +20,7 @@
 #ifndef DACCESS_COMPILE
 
 // get the method table for dynamic methods
-DynamicMethodTable* DomainFile::GetDynamicMethodTable()
+DynamicMethodTable* DomainAssembly::GetDynamicMethodTable()
 {
     CONTRACT (DynamicMethodTable*)
     {
diff --git a/src/coreclr/vm/eventtrace.cpp b/src/coreclr/vm/eventtrace.cpp
index e5473b11041775..3c5d8ded8c574e 100644
--- a/src/coreclr/vm/eventtrace.cpp
+++ b/src/coreclr/vm/eventtrace.cpp
@@ -1380,7 +1380,7 @@ void BulkComLogger::AddCcwHandle(Object **handle)
 
 
 
-#include "domainfile.h"
+#include "domainassembly.h"
 
 BulkStaticsLogger::BulkStaticsLogger(BulkTypeEventLogger *typeLogger)
     : m_buffer(0), m_used(0), m_count(0), m_domain(0), m_typeLogger(typeLogger)
@@ -1524,69 +1524,64 @@ void BulkStaticsLogger::LogAllStatics()
                 continue;
 
             CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetAssembly();
-            DomainModuleIterator modIter = pDomainAssembly->IterateModules(kModIterIncludeLoaded);
+            // Get the domain module from the module/appdomain pair.
+            Module *module = pDomainAssembly->GetModule();
+            if (module == NULL)
+                continue;
 
-            while (modIter.Next())
-            {
-                // Get the domain module from the module/appdomain pair.
-                Module *module = modIter.GetModule();
-                if (module == NULL)
-                    continue;
+            DomainAssembly *domainAssembly = module->GetDomainAssembly();
+            if (domainAssembly == NULL)
+                continue;
 
-                DomainFile *domainFile = module->GetDomainFile();
-                if (domainFile == NULL)
-                    continue;
+            // Ensure the module has fully loaded.
+            if (!domainAssembly->IsActive())
+                continue;
 
-                // Ensure the module has fully loaded.
-                if (!domainFile->IsActive())
+            DomainLocalModule *domainModule = module->GetDomainLocalModule();
+            if (domainModule == NULL)
+                continue;
+
+            // Now iterate all types with
+            LookupMap<PTR_MethodTable>::Iterator mtIter = module->EnumerateTypeDefs();
+            while (mtIter.Next())
+            {
+                // I don't think mt can be null here, but the dac does a null check...
+                // IsFullyLoaded should be equivalent to 'GetLoadLevel() == CLASS_LOADED'
+                MethodTable *mt = mtIter.GetElement();
+                if (mt == NULL || !mt->IsFullyLoaded())
                     continue;
 
-                DomainLocalModule *domainModule = module->GetDomainLocalModule();
-                if (domainModule == NULL)
+                EEClass *cls = mt->GetClass();
+                _ASSERTE(cls != NULL);
+
+                if (cls->GetNumStaticFields() <= 0)
                     continue;
 
-                // Now iterate all types with
-                LookupMap<PTR_MethodTable>::Iterator mtIter = module->EnumerateTypeDefs();
-                while (mtIter.Next())
+                ApproxFieldDescIterator fieldIter(mt, ApproxFieldDescIterator::STATIC_FIELDS);
+                for (FieldDesc *field = fieldIter.Next(); field != NULL; field = fieldIter.Next())
                 {
-                    // I don't think mt can be null here, but the dac does a null check...
-                    // IsFullyLoaded should be equivalent to 'GetLoadLevel() == CLASS_LOADED'
-                    MethodTable *mt = mtIter.GetElement();
-                    if (mt == NULL || !mt->IsFullyLoaded())
+                    // Don't want thread local
+                    _ASSERTE(field->IsStatic());
+                    if (field->IsSpecialStatic() || field->IsEnCNew())
                         continue;
 
-                    EEClass *cls = mt->GetClass();
-                    _ASSERTE(cls != NULL);
+                    // Static valuetype values are boxed.
+                    CorElementType fieldType = field->GetFieldType();
+                    if (fieldType != ELEMENT_TYPE_CLASS && fieldType != ELEMENT_TYPE_VALUETYPE)
+                        continue;
 
-                    if (cls->GetNumStaticFields() <= 0)
+                    BYTE *base = field->GetBaseInDomainLocalModule(domainModule);
+                    if (base == NULL)
                         continue;
 
-                    ApproxFieldDescIterator fieldIter(mt, ApproxFieldDescIterator::STATIC_FIELDS);
-                    for (FieldDesc *field = fieldIter.Next(); field != NULL; field = fieldIter.Next())
-                    {
-                        // Don't want thread local
-                        _ASSERTE(field->IsStatic());
-                        if (field->IsSpecialStatic() || field->IsEnCNew())
-                            continue;
-
-                        // Static valuetype values are boxed.
-                        CorElementType fieldType = field->GetFieldType();
-                        if (fieldType != ELEMENT_TYPE_CLASS && fieldType != ELEMENT_TYPE_VALUETYPE)
-                            continue;
-
-                        BYTE *base = field->GetBaseInDomainLocalModule(domainModule);
-                        if (base == NULL)
-                            continue;
-
-                        Object **address = (Object**)field->GetStaticAddressHandle(base);
-                        Object *obj = NULL;
-                        if (address == NULL || ((obj = *address) == NULL))
-                            continue;
-
-                        WriteEntry(domain, address, *address, field);
-                    } // foreach static field
-                }
-            } // foreach domain module
+                    Object **address = (Object**)field->GetStaticAddressHandle(base);
+                    Object *obj = NULL;
+                    if (address == NULL || ((obj = *address) == NULL))
+                        continue;
+
+                    WriteEntry(domain, address, *address, field);
+                } // foreach static field
+            }
         } // foreach domain assembly
     } // foreach AppDomain
 } // BulkStaticsLogger::LogAllStatics
@@ -6047,7 +6042,7 @@ VOID ETW::LoaderLog::SendAssemblyEvent(Assembly *pAssembly, DWORD dwEventOptions
     PCWSTR szDtraceOutput1=W("");
     BOOL bIsDynamicAssembly = pAssembly->IsDynamic();
     BOOL bIsCollectibleAssembly = pAssembly->IsCollectible();
-    BOOL bIsReadyToRun = pAssembly->GetManifestFile()->IsReadyToRun();
+    BOOL bIsReadyToRun = pAssembly->GetPEAssembly()->IsReadyToRun();
 
     ULONGLONG ullAssemblyId = (ULONGLONG)pAssembly;
     ULONGLONG ullDomainId = (ULONGLONG)pAssembly->GetDomain();
@@ -6338,7 +6333,7 @@ VOID ETW::LoaderLog::SendModuleEvent(Module *pModule, DWORD dwEventOptions, BOOL
 
     if(!bIsDynamicAssembly)
     {
-        ModuleILPath = (PWCHAR)pModule->GetAssembly()->GetManifestFile()->GetPEImage()->GetPath().GetUnicode();
+        ModuleILPath = (PWCHAR)pModule->GetAssembly()->GetPEAssembly()->GetPEImage()->GetPath().GetUnicode();
         ModuleNativePath = (PWCHAR)pEmptyString;
     }
 
@@ -7246,18 +7241,14 @@ VOID ETW::EnumerationLog::IterateDomain(BaseDomain *pDomain, DWORD enumerationOp
         CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
         while (assemblyIterator.Next(pDomainAssembly.This()))
         {
-            CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetLoadedAssembly();
+            CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetAssembly();
             if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
             {
                 ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
             }
 
-            DomainModuleIterator domainModuleIterator = pDomainAssembly->IterateModules(kModIterIncludeLoaded);
-            while (domainModuleIterator.Next())
-            {
-                Module * pModule = domainModuleIterator.GetModule();
-                ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
-            }
+            Module * pModule = pDomainAssembly->GetModule();
+            ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
 
             if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
                 (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload))
@@ -7313,12 +7304,8 @@ VOID ETW::EnumerationLog::IterateCollectibleLoaderAllocator(AssemblyLoaderAlloca
         {
             Assembly *pAssembly = domainAssemblyIt->GetAssembly(); // TODO: handle iterator
 
-            DomainModuleIterator domainModuleIterator = domainAssemblyIt->IterateModules(kModIterIncludeLoaded);
-            while (domainModuleIterator.Next())
-            {
-                Module *pModule = domainModuleIterator.GetModule();
-                ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
-            }
+            Module* pModule = domainAssemblyIt->GetModule();
+            ETW::EnumerationLog::IterateModule(pModule, enumerationOptions);
 
             if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)
             {
@@ -7362,11 +7349,8 @@ VOID ETW::EnumerationLog::IterateAssembly(Assembly *pAssembly, DWORD enumeration
         {
             if(pAssembly->GetDomain()->IsAppDomain())
             {
-                DomainModuleIterator dmIterator = pAssembly->GetDomainAssembly()->IterateModules(kModIterIncludeLoaded);
-                while (dmIterator.Next())
-                {
-                    ETW::LoaderLog::SendModuleEvent(dmIterator.GetModule(), enumerationOptions, TRUE);
-                }
+                Module* pModule = pAssembly->GetDomainAssembly()->GetModule();
+                ETW::LoaderLog::SendModuleEvent(pModule, enumerationOptions, TRUE);
             }
         }
 
diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp
index fa2b8ffc7dfe38..dd80bf37ec6792 100644
--- a/src/coreclr/vm/excep.cpp
+++ b/src/coreclr/vm/excep.cpp
@@ -500,7 +500,7 @@ OBJECTREF PossiblyUnwrapThrowable(OBJECTREF throwable, Assembly *pAssembly)
     // Check if we are required to compute the RuntimeWrapExceptions status.
     BOOL fIsRuntimeWrappedException = ((throwable != NULL) && (throwable->GetMethodTable() == pMT_RuntimeWrappedException));
     BOOL fRequiresComputingRuntimeWrapExceptionsStatus = (fIsRuntimeWrappedException &&
-                                                          (!(pAssembly->GetManifestModule()->IsRuntimeWrapExceptionsStatusComputed())));
+                                                          (!(pAssembly->GetModule()->IsRuntimeWrapExceptionsStatusComputed())));
 
     CONTRACTL
     {
@@ -513,7 +513,7 @@ OBJECTREF PossiblyUnwrapThrowable(OBJECTREF throwable, Assembly *pAssembly)
     }
     CONTRACTL_END;
 
-    if (fIsRuntimeWrappedException && (!pAssembly->GetManifestModule()->IsRuntimeWrapExceptions()))
+    if (fIsRuntimeWrappedException && (!pAssembly->GetModule()->IsRuntimeWrapExceptions()))
     {
         // We already created the instance, fetched the field.  We know it is
         // not marshal by ref, or any of the other cases that might trigger GC.
@@ -12136,8 +12136,8 @@ VOID CheckAndThrowSameTypeAndAssemblyInvalidCastException(TypeHandle thCastFrom,
          _ASSERTE(pAssemblyTypeFrom != NULL);
          _ASSERTE(pAssemblyTypeTo != NULL);
 
-         PEAssembly *pPEAssemblyTypeFrom = pAssemblyTypeFrom->GetManifestFile();
-         PEAssembly *pPEAssemblyTypeTo = pAssemblyTypeTo->GetManifestFile();
+         PEAssembly *pPEAssemblyTypeFrom = pAssemblyTypeFrom->GetPEAssembly();
+         PEAssembly *pPEAssemblyTypeTo = pAssemblyTypeTo->GetPEAssembly();
 
          _ASSERTE(pPEAssemblyTypeFrom != NULL);
          _ASSERTE(pPEAssemblyTypeTo != NULL);
diff --git a/src/coreclr/vm/interoputil.cpp b/src/coreclr/vm/interoputil.cpp
index 3bf1abcfcfbee9..b509a5c221ed18 100644
--- a/src/coreclr/vm/interoputil.cpp
+++ b/src/coreclr/vm/interoputil.cpp
@@ -1063,7 +1063,7 @@ CorClassIfaceAttr ReadClassInterfaceTypeCustomAttribute(TypeHandle type)
     {
         // Check the class interface attribute at the assembly level.
         Assembly *pAssembly = type.GetAssembly();
-        hr = TryParseClassInterfaceAttribute(pAssembly->GetManifestModule(), pAssembly->GetManifestToken(), &attrValueMaybe);
+        hr = TryParseClassInterfaceAttribute(pAssembly->GetModule(), pAssembly->GetManifestToken(), &attrValueMaybe);
         if (FAILED(hr))
             ThrowHR(hr, BFA_BAD_CLASS_INT_CA_FORMAT);
     }
@@ -2501,8 +2501,8 @@ HRESULT GetTypeLibGuidForAssembly(Assembly *pAssembly, GUID *pGuid)
     CQuickArray<BYTE> rName;            // String for guid.
     ULONG       cbData;                 // Size of the string in bytes.
 
-    // Get GUID from Assembly, else from Manifest Module, else Generate from name.
-    hr = pAssembly->GetManifestImport()->GetItemGuid(TokenFromRid(1, mdtAssembly), pGuid);
+    // Get GUID from Assembly, else Generate from name.
+    hr = pAssembly->GetMDImport()->GetItemGuid(TokenFromRid(1, mdtAssembly), pGuid);
 
     if (*pGuid == GUID_NULL)
     {
@@ -2548,7 +2548,7 @@ HRESULT GetTypeLibVersionForAssembly(
     ULONG cbData = 0;
 
     // Check to see if the TypeLibVersionAttribute is set.
-    IfFailRet(pAssembly->GetManifestImport()->GetCustomAttributeByName(TokenFromRid(1, mdtAssembly), INTEROP_TYPELIBVERSION_TYPE, (const void**)&pbData, &cbData));
+    IfFailRet(pAssembly->GetMDImport()->GetCustomAttributeByName(TokenFromRid(1, mdtAssembly), INTEROP_TYPELIBVERSION_TYPE, (const void**)&pbData, &cbData));
 
     // For attribute contents, see https://docs.microsoft.com/dotnet/api/system.runtime.interopservices.typelibversionattribute
     if (cbData >= (2 + 2 * sizeof(UINT32)))
diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp
index 46669283188b9e..27d2452491e2a1 100644
--- a/src/coreclr/vm/jithelpers.cpp
+++ b/src/coreclr/vm/jithelpers.cpp
@@ -1434,7 +1434,7 @@ HCIMPL2(void*, JIT_GetSharedNonGCStaticBaseDynamicClass_Helper, DomainLocalModul
 
     HELPER_METHOD_FRAME_BEGIN_RET_0();
 
-    MethodTable *pMT = pLocalModule->GetDomainFile()->GetModule()->GetDynamicClassMT(dwDynamicClassDomainID);
+    MethodTable *pMT = pLocalModule->GetDomainAssembly()->GetModule()->GetDynamicClassMT(dwDynamicClassDomainID);
     _ASSERTE(pMT);
 
     pMT->CheckRunClassInitThrowing();
@@ -1456,7 +1456,7 @@ HCIMPL2(void*, JIT_GetSharedNonGCStaticBaseDynamicClass, DomainLocalModule *pLoc
     if (pLocalInfo != NULL)
     {
         PTR_BYTE retval;
-        GET_DYNAMICENTRY_NONGCSTATICS_BASEPOINTER(pLocalModule->GetDomainFile()->GetModule()->GetLoaderAllocator(),
+        GET_DYNAMICENTRY_NONGCSTATICS_BASEPOINTER(pLocalModule->GetDomainAssembly()->GetModule()->GetLoaderAllocator(),
                                                pLocalInfo,
                                                &retval);
 
@@ -1478,7 +1478,7 @@ HCIMPL2(void, JIT_ClassInitDynamicClass_Helper, DomainLocalModule *pLocalModule,
 
     HELPER_METHOD_FRAME_BEGIN_0();
 
-    MethodTable *pMT = pLocalModule->GetDomainFile()->GetModule()->GetDynamicClassMT(dwDynamicClassDomainID);
+    MethodTable *pMT = pLocalModule->GetDomainAssembly()->GetModule()->GetDynamicClassMT(dwDynamicClassDomainID);
     _ASSERTE(pMT);
 
     pMT->CheckRunClassInitThrowing();
@@ -1517,7 +1517,7 @@ HCIMPL2(void*, JIT_GetSharedGCStaticBaseDynamicClass_Helper, DomainLocalModule *
 
     HELPER_METHOD_FRAME_BEGIN_RET_0();
 
-    MethodTable *pMT = pLocalModule->GetDomainFile()->GetModule()->GetDynamicClassMT(dwDynamicClassDomainID);
+    MethodTable *pMT = pLocalModule->GetDomainAssembly()->GetModule()->GetDynamicClassMT(dwDynamicClassDomainID);
     _ASSERTE(pMT);
 
     pMT->CheckRunClassInitThrowing();
@@ -1539,7 +1539,7 @@ HCIMPL2(void*, JIT_GetSharedGCStaticBaseDynamicClass, DomainLocalModule *pLocalM
     if (pLocalInfo != NULL)
     {
         PTR_BYTE retval;
-        GET_DYNAMICENTRY_GCSTATICS_BASEPOINTER(pLocalModule->GetDomainFile()->GetModule()->GetLoaderAllocator(),
+        GET_DYNAMICENTRY_GCSTATICS_BASEPOINTER(pLocalModule->GetDomainAssembly()->GetModule()->GetLoaderAllocator(),
                                                pLocalInfo,
                                                &retval);
 
@@ -1853,7 +1853,7 @@ HCIMPL2(void*, JIT_GetSharedNonGCThreadStaticBaseDynamicClass, DomainLocalModule
         if (pLocalInfo != NULL)
         {
             PTR_BYTE retval;
-            GET_DYNAMICENTRY_NONGCTHREADSTATICS_BASEPOINTER(pDomainLocalModule->GetDomainFile()->GetModule()->GetLoaderAllocator(),
+            GET_DYNAMICENTRY_NONGCTHREADSTATICS_BASEPOINTER(pDomainLocalModule->GetDomainAssembly()->GetModule()->GetLoaderAllocator(),
                                                             pLocalInfo,
                                                             &retval);
             return retval;
@@ -1864,7 +1864,7 @@ HCIMPL2(void*, JIT_GetSharedNonGCThreadStaticBaseDynamicClass, DomainLocalModule
     // then we have to go through the slow path
 
     // Obtain the Module
-    Module * pModule = pDomainLocalModule->GetDomainFile()->GetModule();
+    Module * pModule = pDomainLocalModule->GetDomainAssembly()->GetModule();
 
     // Obtain the MethodTable
     MethodTable * pMT = pModule->GetDynamicClassMT(dwDynamicClassDomainID);
@@ -1901,7 +1901,7 @@ HCIMPL2(void*, JIT_GetSharedGCThreadStaticBaseDynamicClass, DomainLocalModule *p
         if (pLocalInfo != NULL)
         {
             PTR_BYTE retval;
-            GET_DYNAMICENTRY_GCTHREADSTATICS_BASEPOINTER(pDomainLocalModule->GetDomainFile()->GetModule()->GetLoaderAllocator(),
+            GET_DYNAMICENTRY_GCTHREADSTATICS_BASEPOINTER(pDomainLocalModule->GetDomainAssembly()->GetModule()->GetLoaderAllocator(),
                                                          pLocalInfo,
                                                          &retval);
 
@@ -1913,7 +1913,7 @@ HCIMPL2(void*, JIT_GetSharedGCThreadStaticBaseDynamicClass, DomainLocalModule *p
     // then we have to go through the slow path
 
     // Obtain the Module
-    Module * pModule = pDomainLocalModule->GetDomainFile()->GetModule();
+    Module * pModule = pDomainLocalModule->GetDomainAssembly()->GetModule();
 
     // Obtain the MethodTable
     MethodTable * pMT = pModule->GetDynamicClassMT(dwDynamicClassDomainID);
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
index 5625deef44c0dc..3a9f5c0207a6bb 100644
--- a/src/coreclr/vm/jitinterface.cpp
+++ b/src/coreclr/vm/jitinterface.cpp
@@ -953,7 +953,7 @@ void CEEInfo::resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken
                 ThrowBadTokenException(pResolvedToken);
 
             {
-                DomainFile *pTargetModule = pModule->LoadModule(GetAppDomain(), metaTOK);
+                DomainAssembly *pTargetModule = pModule->LoadModule(GetAppDomain(), metaTOK);
                 if (pTargetModule == NULL)
                     COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
                 th = TypeHandle(pTargetModule->GetModule()->GetGlobalMethodTable());
@@ -12733,7 +12733,7 @@ PCODE UnsafeJitFunction(PrepareCodeConfig* config,
                 LARGE_INTEGER methodJitTimeStop;
                 QueryPerformanceCounter(&methodJitTimeStop);
                 SString codeBase;
-                ftn->GetModule()->GetDomainFile()->GetPEAssembly()->GetPathOrCodeBase(codeBase);
+                ftn->GetModule()->GetDomainAssembly()->GetPEAssembly()->GetPathOrCodeBase(codeBase);
                 codeBase.AppendPrintf(W(",0x%x,%d,%d\n"),
                                  //(const WCHAR *)codeBase, //module name
                                  ftn->GetMemberDef(), //method token
diff --git a/src/coreclr/vm/loaderallocator.cpp b/src/coreclr/vm/loaderallocator.cpp
index 5b5c9d142c89db..657ff7b2b40cec 100644
--- a/src/coreclr/vm/loaderallocator.cpp
+++ b/src/coreclr/vm/loaderallocator.cpp
@@ -360,7 +360,7 @@ LoaderAllocator * LoaderAllocator::GCLoaderAllocators_RemoveAssemblies(AppDomain
         while (iData.Next_Unlocked(pDomainAssembly.This()))
         {
             // The assembly could be collected (ref-count = 0), do not use holder which calls add-ref
-            Assembly * pAssembly = pDomainAssembly->GetLoadedAssembly();
+            Assembly * pAssembly = pDomainAssembly->GetAssembly();
 
             if (pAssembly != NULL)
             {
@@ -393,7 +393,7 @@ LoaderAllocator * LoaderAllocator::GCLoaderAllocators_RemoveAssemblies(AppDomain
         while (i.Next_Unlocked(pDomainAssembly.This()))
         {
             // The assembly could be collected (ref-count = 0), do not use holder which calls add-ref
-            Assembly * pAssembly = pDomainAssembly->GetLoadedAssembly();
+            Assembly * pAssembly = pDomainAssembly->GetAssembly();
 
             if (pAssembly != NULL)
             {
@@ -420,7 +420,7 @@ LoaderAllocator * LoaderAllocator::GCLoaderAllocators_RemoveAssemblies(AppDomain
         while (i.Next_Unlocked(pDomainAssembly.This()))
         {
             // The assembly could be collected (ref-count = 0), do not use holder which calls add-ref
-            Assembly * pAssembly = pDomainAssembly->GetLoadedAssembly();
+            Assembly * pAssembly = pDomainAssembly->GetAssembly();
 
             if (pAssembly != NULL)
             {
@@ -672,7 +672,7 @@ BOOL LoaderAllocator::Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator)
         DomainAssembly* pDomainAssembly = (DomainAssembly*)(pID->GetDomainAssemblyIterator());
         if (pDomainAssembly != NULL)
         {
-            Assembly *pAssembly = pDomainAssembly->GetCurrentAssembly();
+            Assembly *pAssembly = pDomainAssembly->GetAssembly();
             pLoaderAllocator->m_pFirstDomainAssemblyFromSameALCToDelete = pAssembly->GetDomainAssembly();
         }
 
diff --git a/src/coreclr/vm/memberload.cpp b/src/coreclr/vm/memberload.cpp
index 78fdb518a1618e..4c8e7dc7e2a925 100644
--- a/src/coreclr/vm/memberload.cpp
+++ b/src/coreclr/vm/memberload.cpp
@@ -277,7 +277,7 @@ void MemberLoader::GetDescFromMemberRef(Module * pModule,
     {
     case mdtModuleRef:
         {
-            DomainFile *pTargetModule = pModule->LoadModule(GetAppDomain(), parent);
+            DomainAssembly *pTargetModule = pModule->LoadModule(GetAppDomain(), parent);
             if (pTargetModule == NULL)
                 COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
             typeHnd = TypeHandle(pTargetModule->GetModule()->GetGlobalMethodTable());
diff --git a/src/coreclr/vm/methoditer.cpp b/src/coreclr/vm/methoditer.cpp
index 841b3214d2e2d5..da24a53d064a17 100644
--- a/src/coreclr/vm/methoditer.cpp
+++ b/src/coreclr/vm/methoditer.cpp
@@ -77,11 +77,7 @@ BOOL LoadedMethodDescIterator::Next(
     dbg_m_pDomainAssembly = *pDomainAssemblyHolder;
 #endif //_DEBUG
 
-    m_moduleIterator = (*pDomainAssemblyHolder)->IterateModules(m_moduleIterationFlags);
-
-ADVANCE_MODULE:
-    if  (!m_moduleIterator.Next())
-        goto ADVANCE_ASSEMBLY;
+    m_currentModule = (*pDomainAssemblyHolder)->GetModule();
 
     if (m_mainMD->HasClassInstantiation())
     {
@@ -96,7 +92,7 @@ BOOL LoadedMethodDescIterator::Next(
     if (m_mainMD->HasClassInstantiation())
     {
         if (!GetCurrentModule()->GetAvailableParamTypes()->FindNext(&m_typeIterator, &m_typeIteratorEntry))
-            goto ADVANCE_MODULE;
+            goto ADVANCE_ASSEMBLY;
         if (CORCOMPILE_IS_POINTER_TAGGED(m_typeIteratorEntry->GetTypeHandle().AsTAddr()))
             goto ADVANCE_TYPE;
 
@@ -130,7 +126,7 @@ BOOL LoadedMethodDescIterator::Next(
     }
     else if (m_startedNonGenericType)
     {
-        goto ADVANCE_MODULE;
+        goto ADVANCE_ASSEMBLY;
     }
     else
     {
@@ -188,7 +184,7 @@ Module * LoadedMethodDescIterator::GetCurrentModule()
     }
     CONTRACTL_END
 
-    return m_moduleIterator.GetLoadedModule();
+    return m_currentModule;
 }
 
 MethodDesc *LoadedMethodDescIterator::Current()
@@ -228,8 +224,7 @@ LoadedMethodDescIterator::Start(
     AppDomain * pAppDomain,
     Module *pModule,
     mdMethodDef md,
-    AssemblyIterationFlags assemblyIterationFlags,
-    ModuleIterationOption moduleIterationFlags)
+    AssemblyIterationFlags assemblyIterationFlags)
 {
     CONTRACTL
     {
@@ -241,7 +236,6 @@ LoadedMethodDescIterator::Start(
     CONTRACTL_END;
 
     m_assemIterationFlags = assemblyIterationFlags;
-    m_moduleIterationFlags = moduleIterationFlags;
     m_mainMD = NULL;
     m_module = pModule;
     m_md = md;
diff --git a/src/coreclr/vm/methoditer.h b/src/coreclr/vm/methoditer.h
index 71192be2e0c01a..fdc49e2ce59710 100644
--- a/src/coreclr/vm/methoditer.h
+++ b/src/coreclr/vm/methoditer.h
@@ -9,7 +9,7 @@
 #include "instmethhash.h"
 #include "method.hpp"
 #include "appdomain.hpp"
-#include "domainfile.h"
+#include "domainassembly.h"
 #include "typehash.h"
 
 
@@ -44,9 +44,8 @@ class LoadedMethodDescIterator
 
     // These are used when iterating over an AppDomain
     AppDomain::AssemblyIterator             m_assemIterator;
-    DomainModuleIterator                    m_moduleIterator;
+    Module*                                 m_currentModule;
     AssemblyIterationFlags                  m_assemIterationFlags;
-    ModuleIterationOption                   m_moduleIterationFlags;
 
     EETypeHashTable::Iterator               m_typeIterator;
     EETypeHashEntry *                       m_typeIteratorEntry;
@@ -69,19 +68,17 @@ class LoadedMethodDescIterator
     void Start(AppDomain * pAppDomain,
                Module *pModule,
                mdMethodDef md,
-               AssemblyIterationFlags assemIterationFlags = (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution),
-               ModuleIterationOption moduleIterationFlags = kModIterIncludeLoaded);
+               AssemblyIterationFlags assemIterationFlags = (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution));
     void Start(AppDomain * pAppDomain, Module *pModule, mdMethodDef md, MethodDesc *pDesc);
 
     LoadedMethodDescIterator(
         AppDomain * pAppDomain,
         Module *pModule,
         mdMethodDef md,
-        AssemblyIterationFlags assemblyIterationFlags = (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution),
-        ModuleIterationOption moduleIterationFlags = kModIterIncludeLoaded)
+        AssemblyIterationFlags assemblyIterationFlags = (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution))
     {
         LIMITED_METHOD_CONTRACT;
-        Start(pAppDomain, pModule, md, assemblyIterationFlags, moduleIterationFlags);
+        Start(pAppDomain, pModule, md, assemblyIterationFlags);
     }
     LoadedMethodDescIterator(void);
 
diff --git a/src/coreclr/vm/multicorejit.cpp b/src/coreclr/vm/multicorejit.cpp
index b747608a184783..18a0a141a8228b 100644
--- a/src/coreclr/vm/multicorejit.cpp
+++ b/src/coreclr/vm/multicorejit.cpp
@@ -234,11 +234,11 @@ FileLoadLevel MulticoreJitManager::GetModuleFileLoadLevel(Module * pModule)
 
     if (pModule != NULL)
     {
-        DomainFile * pDomainFile = pModule->GetDomainFile();
+        DomainAssembly * pDomainAssembly = pModule->GetDomainAssembly();
 
-        if (pDomainFile != NULL)
+        if (pDomainAssembly != NULL)
         {
-            level = pDomainFile->GetLoadLevel();
+            level = pDomainAssembly->GetLoadLevel();
         }
     }
 
@@ -310,7 +310,7 @@ bool RecorderModuleInfo::SetModule(Module * pMod)
 
     SString sAssemblyName;
     StackScratchBuffer scratch;
-    pMod->GetAssembly()->GetManifestFile()->GetDisplayName(sAssemblyName);
+    pMod->GetAssembly()->GetPEAssembly()->GetDisplayName(sAssemblyName);
 
     LPCUTF8 pAssemblyName = sAssemblyName.GetUTF8(scratch);
     unsigned lenAssemblyName = sAssemblyName.GetCount();
@@ -770,21 +770,8 @@ HRESULT MulticoreJitModuleEnumerator::HandleAssembly(DomainAssembly * pAssembly)
 {
     STANDARD_VM_CONTRACT;
 
-    DomainAssembly::ModuleIterator modIt = pAssembly->IterateModules(kModIterIncludeLoaded);
-
-    HRESULT hr = S_OK;
-
-    while (modIt.Next() && SUCCEEDED(hr))
-    {
-        Module * pModule = modIt.GetModule();
-
-        if (pModule != NULL)
-        {
-            hr = OnModule(pModule);
-        }
-    }
-
-    return hr;
+    Module * pModule = pAssembly->GetModule();
+    return OnModule(pModule);
 }
 
 
diff --git a/src/coreclr/vm/nativeimage.cpp b/src/coreclr/vm/nativeimage.cpp
index 3bb47cff1acb31..2664a44ad2d18b 100644
--- a/src/coreclr/vm/nativeimage.cpp
+++ b/src/coreclr/vm/nativeimage.cpp
@@ -289,7 +289,7 @@ void NativeImage::CheckAssemblyMvid(Assembly *assembly) const
     }
 
     GUID assemblyMvid;
-    assembly->GetManifestImport()->GetScopeProps(NULL, &assemblyMvid);
+    assembly->GetMDImport()->GetScopeProps(NULL, &assemblyMvid);
 
     const byte *pImageBase = (const BYTE *)m_pImageLayout->GetBase();
     const GUID *componentMvid = (const GUID *)&pImageBase[m_pComponentAssemblyMvids->VirtualAddress] + assemblyNameIndex->Index;
diff --git a/src/coreclr/vm/nativelibrary.cpp b/src/coreclr/vm/nativelibrary.cpp
index 9be259ec200d8c..e050e0b1719ff8 100644
--- a/src/coreclr/vm/nativelibrary.cpp
+++ b/src/coreclr/vm/nativelibrary.cpp
@@ -318,7 +318,7 @@ namespace
 #endif // !TARGET_UNIX
 
         NATIVE_LIBRARY_HANDLE hmod = NULL;
-        PEAssembly *pManifestFile = pAssembly->GetManifestFile();
+        PEAssembly *pManifestFile = pAssembly->GetPEAssembly();
         PTR_AssemblyBinder pBinder = pManifestFile->GetAssemblyBinder();
 
         //Step 0: Check if  the assembly was bound using TPA.
@@ -363,7 +363,7 @@ namespace
     {
         STANDARD_VM_CONTRACT;
 
-        PTR_AssemblyBinder pBinder = pAssembly->GetManifestFile()->GetAssemblyBinder();
+        PTR_AssemblyBinder pBinder = pAssembly->GetPEAssembly()->GetAssemblyBinder();
         return pBinder->GetManagedAssemblyLoadContext();
     }
 
@@ -461,7 +461,7 @@ namespace
 
         NATIVE_LIBRARY_HANDLE hmod = NULL;
 
-        SString path = pAssembly->GetManifestFile()->GetPath();
+        SString path = pAssembly->GetPEAssembly()->GetPath();
 
         SString::Iterator lastPathSeparatorIter = path.End();
         if (PEAssembly::FindLastPathSeparator(path, lastPathSeparatorIter))
@@ -771,7 +771,7 @@ NATIVE_LIBRARY_HANDLE NativeLibrary::LoadLibraryByName(LPCWSTR libraryName, Asse
     }
     else
     {
-        GetDllImportSearchPathFlags(callingAssembly->GetManifestModule(),
+        GetDllImportSearchPathFlags(callingAssembly->GetModule(),
                                     &dllImportSearchPathFlags, &searchAssemblyDirectory);
     }
 
diff --git a/src/coreclr/vm/peassembly.cpp b/src/coreclr/vm/peassembly.cpp
index 9f228fdb5af825..7926fa8b85bf8c 100644
--- a/src/coreclr/vm/peassembly.cpp
+++ b/src/coreclr/vm/peassembly.cpp
@@ -552,7 +552,7 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
         pDomainAssembly = pAssembly->GetDomainAssembly();
         pPEAssembly = pDomainAssembly->GetPEAssembly();
 
-        if (FAILED(pAssembly->GetManifestImport()->FindManifestResourceByName(
+        if (FAILED(pAssembly->GetMDImport()->FindManifestResourceByName(
             szName,
             &mdResource)))
         {
@@ -1080,7 +1080,7 @@ void PEAssembly::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
     WRAPPER_NO_CONTRACT;
     SUPPORTS_DAC;
 
-    DAC_ENUM_VTHIS();
+    DAC_ENUM_DTHIS();
     EMEM_OUT(("MEM: %p PEAssembly\n", dac_cast<TADDR>(this)));
 
 #ifdef _DEBUG
diff --git a/src/coreclr/vm/peassembly.h b/src/coreclr/vm/peassembly.h
index 3342e835f265a3..8cb12f986c8bb3 100644
--- a/src/coreclr/vm/peassembly.h
+++ b/src/coreclr/vm/peassembly.h
@@ -83,11 +83,6 @@ typedef VPTR(PEAssembly) PTR_PEAssembly;
 
 class PEAssembly final
 {
-    // ------------------------------------------------------------
-    // SOS support
-    // ------------------------------------------------------------
-    VPTR_BASE_CONCRETE_VTABLE_CLASS(PEAssembly)
-
 public:
 
     // ------------------------------------------------------------
@@ -98,7 +93,7 @@ class PEAssembly final
     STDMETHOD_(ULONG, Release)();
 
 #ifdef DACCESS_COMPILE
-    virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
+    void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
 #endif
 
 #if CHECK_INVARIANTS
@@ -381,7 +376,7 @@ class PEAssembly final
 
 #ifdef DACCESS_COMPILE
     // just to make the DAC and GCC happy.
-    virtual ~PEAssembly() {};
+    ~PEAssembly() {};
     PEAssembly() = default;
 #else
     PEAssembly(
@@ -393,7 +388,7 @@ class PEAssembly final
         BINDER_SPACE::Assembly* pHostAssembly = NULL
     );
 
-    virtual ~PEAssembly();
+    ~PEAssembly();
 #endif
 
     void OpenMDImport();
diff --git a/src/coreclr/vm/perfmap.cpp b/src/coreclr/vm/perfmap.cpp
index 30708584c3f72e..5e004f6ed0c1fc 100644
--- a/src/coreclr/vm/perfmap.cpp
+++ b/src/coreclr/vm/perfmap.cpp
@@ -393,7 +393,7 @@ NativeImagePerfMap::NativeImagePerfMap(Assembly * pAssembly, BSTR pDestPath)
     // Get the native image signature (GUID).
     // Used to ensure that we match symbols to the correct NGEN image.
     WCHAR wszSignature[39];
-    GetNativeImageSignature(pAssembly->GetManifestFile(), wszSignature, ARRAY_SIZE(wszSignature));
+    GetNativeImageSignature(pAssembly->GetPEAssembly(), wszSignature, ARRAY_SIZE(wszSignature));
 
     // Build the path to the perfmap file, which consists of <inputpath><imagesimplename>.ni.<signature>.map.
     // Example: /tmp/System.Private.CoreLib.ni.{GUID}.map
diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp
index a4fdb065285ddf..681301621f72ff 100644
--- a/src/coreclr/vm/prestub.cpp
+++ b/src/coreclr/vm/prestub.cpp
@@ -520,7 +520,7 @@ PCODE MethodDesc::GetPrecompiledR2RCode(PrepareCodeConfig* pConfig)
     // Lookup in the entry point assembly for a R2R entrypoint (generics with large version bubble enabled)
     if (pCode == NULL && HasClassOrMethodInstantiation() && SystemDomain::System()->DefaultDomain()->GetRootAssembly() != NULL)
     {
-        pModule = SystemDomain::System()->DefaultDomain()->GetRootAssembly()->GetManifestModule();
+        pModule = SystemDomain::System()->DefaultDomain()->GetRootAssembly()->GetModule();
         _ASSERT(pModule != NULL);
 
         if (pModule->IsReadyToRun() && pModule->IsInSameVersionBubble(GetModule()))
diff --git a/src/coreclr/vm/profilingenumerators.cpp b/src/coreclr/vm/profilingenumerators.cpp
index 609b57cf4ee3ab..7d537924df8919 100644
--- a/src/coreclr/vm/profilingenumerators.cpp
+++ b/src/coreclr/vm/profilingenumerators.cpp
@@ -250,7 +250,7 @@ HRESULT IterateUnsharedModules(AppDomain * pAppDomain,
     //             enumerable.
     //
     // Note: To determine what happens in a given load stage of a module or assembly,
-    // look at the switch statement in code:DomainFile::DoIncrementalLoad, and keep in
+    // look at the switch statement in code:DomainAssembly::DoIncrementalLoad, and keep in
     // mind that it takes cases on the *next* load stage; in other words, the actions
     // that appear in a case for a given load stage are actually executed as we attempt
     // to transition TO that load stage, and thus they actually execute while the module
@@ -282,21 +282,14 @@ HRESULT IterateUnsharedModules(AppDomain * pAppDomain,
         //     < Module NOT available from catch-up enumeration
         //     < ModuleUnloadStarted issued
         //
-        // The IterateModules parameter below ensures only modules at level >=
-        // code:FILE_LOAD_LOADLIBRARY will be included in the iteration.
-        //
         // Details for module callbacks are the same as those for assemblies, so see
         // code:#ProfilerEnumAssemblies for info on how the timing works.
-        DomainModuleIterator domainModuleIterator =
-            pDomainAssembly->IterateModules(kModIterIncludeAvailableToProfilers);
-        while (domainModuleIterator.Next())
+
+        // Call user-supplied callback, and cancel iteration if requested
+        HRESULT hr = (callbackObj->*callbackMethod)(pDomainAssembly->GetModule());
+        if (hr != S_OK)
         {
-            // Call user-supplied callback, and cancel iteration if requested
-            HRESULT hr = (callbackObj->*callbackMethod)(domainModuleIterator.GetModule());
-            if (hr != S_OK)
-            {
-                return hr;
-            }
+            return hr;
         }
     }
 
@@ -402,9 +395,9 @@ HRESULT ProfilerModuleEnum::Init()
 
     HRESULT hr = S_OK;
 
-    // When an assembly or module is loaded into an AppDomain, a separate DomainFile is
-    // created (one per pairing of the AppDomain with the module or assembly). This means
-    // that we'll create multiple DomainFiles for the same module if it is loaded
+    // When an assembly is loaded into an AppDomain, a DomainAssembly is
+    // created (one per pairing of the AppDomain with the assembly). This means
+    // that we'll create multiple DomainAssemblys for the same module if it is loaded
     // domain-neutral (i.e., "shared"). The profiling API callbacks shield the profiler
     // from this, and only report a given module the first time it's loaded. So a
     // profiler sees only one ModuleLoadFinished for a module loaded domain-neutral, even
@@ -457,8 +450,8 @@ HRESULT IterateAppDomainContainingModule::AddAppDomainContainingModule(AppDomain
     }
     CONTRACTL_END;
 
-    DomainFile * pDomainFile = m_pModule->GetDomainFile();
-    if ((pDomainFile != NULL) && (pDomainFile->IsAvailableToProfilers()))
+    DomainAssembly * pDomainAssembly = m_pModule->GetDomainAssembly();
+    if ((pDomainAssembly != NULL) && (pDomainAssembly->IsAvailableToProfilers()))
     {
         if (m_index < m_cAppDomainIds)
         {
diff --git a/src/coreclr/vm/proftoeeinterfaceimpl.cpp b/src/coreclr/vm/proftoeeinterfaceimpl.cpp
index 50e57f8144eef3..5162ac38a3bb4c 100644
--- a/src/coreclr/vm/proftoeeinterfaceimpl.cpp
+++ b/src/coreclr/vm/proftoeeinterfaceimpl.cpp
@@ -5710,7 +5710,7 @@ HRESULT ProfToEEInterfaceImpl::GetAssemblyInfo(AssemblyID    assemblyId,
     // Find the module the manifest lives in.
     if (pModuleId)
     {
-        *pModuleId = (ModuleID) pAssembly->GetManifestModule();
+        *pModuleId = (ModuleID) pAssembly->GetModule();
 
         // This is the case where the profiler has called GetAssemblyInfo
         // on an assembly that has been completely created yet.
diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp
index 495e10e4f4a365..e49ad881f5fe54 100644
--- a/src/coreclr/vm/reflectioninvocation.cpp
+++ b/src/coreclr/vm/reflectioninvocation.cpp
@@ -1579,19 +1579,17 @@ extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHa
     END_QCALL;
 }
 
-// This method triggers the module constructor for a give module
+// This method triggers the module constructor for a given module
 extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule)
 {
     QCALL_CONTRACT;
 
-    DomainFile *pDomainFile = pModule->GetDomainFile();
-    if (pDomainFile != NULL && pDomainFile->IsActive())
+    DomainAssembly *pDomainAssembly = pModule->GetDomainAssembly();
+    if (pDomainAssembly != NULL && pDomainAssembly->IsActive())
         return;
 
     BEGIN_QCALL;
-    if(pDomainFile == NULL)
-        pDomainFile = pModule->GetDomainFile();
-    pDomainFile->EnsureActive();
+    pDomainAssembly->EnsureActive();
     END_QCALL;
 }
 
diff --git a/src/coreclr/vm/rejit.cpp b/src/coreclr/vm/rejit.cpp
index aaf335390764cb..80f05489ad3b2f 100644
--- a/src/coreclr/vm/rejit.cpp
+++ b/src/coreclr/vm/rejit.cpp
@@ -811,35 +811,31 @@ HRESULT ReJitManager::UpdateNativeInlinerActiveILVersions(
         _ASSERTE(pDomainAssembly != NULL);
         _ASSERTE(pDomainAssembly->GetAssembly() != NULL);
 
-        DomainModuleIterator domainModuleIterator = pDomainAssembly->IterateModules(kModIterIncludeLoaded);
-        while (domainModuleIterator.Next())
+        Module * pModule = pDomainAssembly->GetModule();
+        if (pModule->HasReadyToRunInlineTrackingMap())
         {
-            Module * pCurModule = domainModuleIterator.GetModule();
-            if (pCurModule->HasReadyToRunInlineTrackingMap())
-            {
-                inlinerIter.Reset(pCurModule, pInlinee);
+            inlinerIter.Reset(pModule, pInlinee);
 
-                MethodDesc *pInliner = NULL;
-                while (inlinerIter.Next())
+            MethodDesc *pInliner = NULL;
+            while (inlinerIter.Next())
+            {
+                pInliner = inlinerIter.GetMethodDesc();
                 {
-                    pInliner = inlinerIter.GetMethodDesc();
+                    CodeVersionManager *pCodeVersionManager = pModule->GetCodeVersionManager();
+                    CodeVersionManager::LockHolder codeVersioningLockHolder;
+                    ILCodeVersion ilVersion = pCodeVersionManager->GetActiveILCodeVersion(pInliner);
+                    if (!ilVersion.HasDefaultIL())
                     {
-                        CodeVersionManager *pCodeVersionManager = pCurModule->GetCodeVersionManager();
-                        CodeVersionManager::LockHolder codeVersioningLockHolder;
-                        ILCodeVersion ilVersion = pCodeVersionManager->GetActiveILCodeVersion(pInliner);
-                        if (!ilVersion.HasDefaultIL())
-                        {
-                            // This method has already been ReJITted, no need to request another ReJIT at this point.
-                            // The ReJITted method will be in the JIT inliner check below.
-                            continue;
-                        }
+                        // This method has already been ReJITted, no need to request another ReJIT at this point.
+                        // The ReJITted method will be in the JIT inliner check below.
+                        continue;
                     }
+                }
 
-                    hr = UpdateActiveILVersion(pMgrToCodeActivationBatch, pInliner->GetModule(), pInliner->GetMemberDef(), fIsRevert, flags);
-                    if (FAILED(hr))
-                    {
-                        ReportReJITError(pInliner->GetModule(), pInliner->GetMemberDef(), NULL, hr);
-                    }
+                hr = UpdateActiveILVersion(pMgrToCodeActivationBatch, pInliner->GetModule(), pInliner->GetMemberDef(), fIsRevert, flags);
+                if (FAILED(hr))
+                {
+                    ReportReJITError(pInliner->GetModule(), pInliner->GetMemberDef(), NULL, hr);
                 }
             }
         }
diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp
index 41057e01620d38..362ea14986498e 100644
--- a/src/coreclr/vm/runtimehandles.cpp
+++ b/src/coreclr/vm/runtimehandles.cpp
@@ -186,9 +186,9 @@ NOINLINE ReflectModuleBaseObject* GetRuntimeModuleHelper(LPVOID __me, Module *pM
     if (pModule == NULL)
         return NULL;
 
-    DomainFile * pDomainFile = pModule->GetDomainFile();
+    DomainAssembly * pDomainAssembly = pModule->GetDomainAssembly();
 
-    OBJECTREF refModule = (pDomainFile != NULL) ? pDomainFile->GetExposedModuleObjectIfExists() : NULL;
+    OBJECTREF refModule = (pDomainAssembly != NULL) ? pDomainAssembly->GetExposedModuleObjectIfExists() : NULL;
 
     if(refModule != NULL)
         return (ReflectModuleBaseObject*)OBJECTREFToObject(refModule);
@@ -354,7 +354,7 @@ FCIMPL1(AssemblyBaseObject*, RuntimeTypeHandle::GetAssembly, ReflectClassBaseObj
     if (refType == NULL)
         FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
 
-    Module *pModule = refType->GetType().GetAssembly()->GetManifestModule();
+    Module *pModule = refType->GetType().GetAssembly()->GetModule();
     DomainAssembly *pDomainAssembly = pModule->GetDomainAssembly();
 
     FC_RETURN_ASSEMBLY_OBJECT(pDomainAssembly, refType);
@@ -2667,20 +2667,20 @@ FCIMPL1(ReflectModuleBaseObject*, AssemblyHandle::GetManifestModule, AssemblyBas
         FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
 
     DomainAssembly *pAssembly = refAssembly->GetDomainAssembly();
-    Assembly* currentAssembly = pAssembly->GetCurrentAssembly();
+    Assembly* currentAssembly = pAssembly->GetAssembly();
 
-    Module *pModule = currentAssembly->GetManifestModule();
-    DomainFile * pDomainFile = pModule->GetDomainFile();
+    Module *pModule = currentAssembly->GetModule();
+    DomainAssembly * pDomainAssembly = pModule->GetDomainAssembly();
 
 #ifdef _DEBUG
     OBJECTREF orModule;
 
     HELPER_METHOD_FRAME_BEGIN_RET_1(refAssembly);
-    orModule = (pDomainFile != NULL) ? pDomainFile->GetExposedModuleObjectIfExists() : NULL;
+    orModule = (pDomainAssembly != NULL) ? pDomainAssembly->GetExposedModuleObjectIfExists() : NULL;
     if (orModule == NULL)
         orModule = pModule->GetExposedObject();
 #else
-    OBJECTREF orModule = (pDomainFile != NULL) ? pDomainFile->GetExposedModuleObjectIfExists() : NULL;
+    OBJECTREF orModule = (pDomainAssembly != NULL) ? pDomainAssembly->GetExposedModuleObjectIfExists() : NULL;
     if (orModule != NULL)
         return (ReflectModuleBaseObject*)OBJECTREFToObject(orModule);
 
@@ -2705,7 +2705,7 @@ FCIMPL1(INT32, AssemblyHandle::GetToken, AssemblyBaseObject* pAssemblyUNSAFE) {
     DomainAssembly *pAssembly = refAssembly->GetDomainAssembly();
     mdAssembly token = mdAssemblyNil;
 
-    IMDInternalImport *mdImport = pAssembly->GetCurrentAssembly()->GetManifestImport();
+    IMDInternalImport *mdImport = pAssembly->GetAssembly()->GetMDImport();
 
     if (mdImport != 0)
     {
@@ -2905,7 +2905,7 @@ FCIMPL5(ReflectMethodObject*, ModuleHandle::GetDynamicMethod, ReflectMethodObjec
 
     HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
 
-    DomainFile *pDomainModule = pModule->GetDomainFile();
+    DomainAssembly *pDomainModule = pModule->GetDomainAssembly();
 
     U1ARRAYREF dataArray = (U1ARRAYREF)sig;
     DWORD sigSize = dataArray->GetNumComponents();
diff --git a/src/coreclr/vm/threads.cpp b/src/coreclr/vm/threads.cpp
index de38922580b79c..20bdfcc6fcc6eb 100644
--- a/src/coreclr/vm/threads.cpp
+++ b/src/coreclr/vm/threads.cpp
@@ -8530,8 +8530,8 @@ Thread::EnumMemoryRegionsWorker(CLRDataEnumMemoryFlags flags)
         DacEnumCodeForStackwalk(callEnd);
 
         // To stackwalk through funceval frames, we need to be sure to preserve the
-        // DebuggerModule's m_pRuntimeDomainFile.  This is the only case that doesn't use the current
-        // vmDomainFile in code:DacDbiInterfaceImpl::EnumerateInternalFrames.  The following
+        // DebuggerModule's m_pRuntimeDomainAssembly.  This is the only case that doesn't use the current
+        // vmDomainAssembly in code:DacDbiInterfaceImpl::EnumerateInternalFrames.  The following
         // code mimics that function.
         // Allow failure, since we want to continue attempting to walk the stack regardless of the outcome.
         EX_TRY
diff --git a/src/coreclr/vm/threads.h b/src/coreclr/vm/threads.h
index 1bfccb85e10d6f..f51f75445b3995 100644
--- a/src/coreclr/vm/threads.h
+++ b/src/coreclr/vm/threads.h
@@ -132,7 +132,7 @@ class     Frame;
 class     ThreadBaseObject;
 class     AppDomainStack;
 class     LoadLevelLimiter;
-class     DomainFile;
+class     DomainAssembly;
 class     DeadlockAwareLock;
 struct    HelperMethodFrameCallerList;
 class     ThreadLocalIBCInfo;
diff --git a/src/coreclr/vm/typeparse.cpp b/src/coreclr/vm/typeparse.cpp
index 524a9e595bc245..dab28d4703f175 100644
--- a/src/coreclr/vm/typeparse.cpp
+++ b/src/coreclr/vm/typeparse.cpp
@@ -1273,7 +1273,7 @@ TypeName::GetTypeHaveAssemblyHelper(
 
     TypeHandle th = TypeHandle();
     SArray<SString *> & names = GetNames();
-    Module *      pManifestModule = pAssembly->GetManifestModule();
+    Module *      pManifestModule = pAssembly->GetModule();
     Module *      pLookOnlyInModule = NULL;
     ClassLoader * pClassLoader = pAssembly->GetLoader();
 
@@ -1427,7 +1427,7 @@ DomainAssembly * LoadDomainAssembly(
     {
         // If the requesting assembly has Fallback LoadContext binder available,
         // then set it up in the AssemblySpec.
-        PEAssembly *pRequestingAssemblyManifestFile = pRequestingAssembly->GetManifestFile();
+        PEAssembly *pRequestingAssemblyManifestFile = pRequestingAssembly->GetPEAssembly();
         spec.SetFallbackBinderForRequestingAssembly(pRequestingAssemblyManifestFile->GetFallbackBinder());
     }
 
diff --git a/src/coreclr/vm/zapsig.cpp b/src/coreclr/vm/zapsig.cpp
index dbdff7a98c8f5b..b66c7b10571384 100644
--- a/src/coreclr/vm/zapsig.cpp
+++ b/src/coreclr/vm/zapsig.cpp
@@ -620,7 +620,7 @@ Module *ZapSig::DecodeModuleFromIndex(Module *fromModule,
         }
     }
 
-    return pAssembly->GetManifestModule();
+    return pAssembly->GetModule();
 }
 
 Module *ZapSig::DecodeModuleFromIndexIfLoaded(Module *fromModule,
@@ -686,7 +686,7 @@ Module *ZapSig::DecodeModuleFromIndexIfLoaded(Module *fromModule,
     if (pAssembly == NULL)
         return NULL;
 
-    return pAssembly->GetManifestModule();
+    return pAssembly->GetModule();
 }
 
 

From 73a5fcd2f934eb363d1517b42fc59527da8a6dcf Mon Sep 17 00:00:00 2001
From: Andy Ayers <andya@microsoft.com>
Date: Fri, 28 Jan 2022 17:14:41 -0800
Subject: [PATCH 158/161] JIT: fix x86 codegen issue (#64476)

We were not calling `genProduceReg` in one case, leading to a missing
def and liveness assert. Normally this would have been a temp assign
followed by a copy to a local; evidently we don't track liveness for
temps and so don't notice the missing def, and the subsequent copy defs
the local and all seems well.

Forward sub gets rid of the copy and exposes the issue under jit stress.
---
 src/coreclr/jit/codegenxarch.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/coreclr/jit/codegenxarch.cpp b/src/coreclr/jit/codegenxarch.cpp
index 7da0bd72856251..cfc97dc6b1370c 100644
--- a/src/coreclr/jit/codegenxarch.cpp
+++ b/src/coreclr/jit/codegenxarch.cpp
@@ -1972,6 +1972,7 @@ void CodeGen::genMultiRegStoreToSIMDLocal(GenTreeLclVar* lclNode)
             inst_Mov(TYP_FLOAT, tempXmm, reg1, /* canSkip */ false);
             GetEmitter()->emitIns_SIMD_R_R_R(INS_punpckldq, size, targetReg, targetReg, tempXmm);
         }
+        genProduceReg(lclNode);
     }
 #elif defined(TARGET_AMD64)
     assert(!TargetOS::IsWindows || !"Multireg store to SIMD reg not supported on Windows x64");

From 55fcfecfcb66222ec8d9d6e780a937bbbb5f5fce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Rylek?= <trylek@microsoft.com>
Date: Sat, 29 Jan 2022 02:34:54 +0100
Subject: [PATCH 159/161] Temporarily disable test Runtime_60035 failing with
 Crossgen2 (#64420)

---
 src/tests/issues.targets | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index 2b1420abd4f7c1..d14ab8edbdbc12 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -820,6 +820,9 @@
         <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/CLR-x86-JIT/v2.1/DDB/B168384/LdfldaHack/*">
             <Issue>https://github.com/dotnet/runtime/issues/615</Issue>
         </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/JIT/Regression/JitBlue/Runtime_60035/Runtime_60035/*">
+            <Issue>https://github.com/dotnet/runtime/issues/64419</Issue>
+        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/JIT/superpmi/superpmicollect/*">
             <Issue>Not compatible with crossgen2</Issue>
         </ExcludeList>

From 8471eecd98e5493e3fbc8bcc34662310ef8762eb Mon Sep 17 00:00:00 2001
From: Zoltan Varga <vargaz@gmail.com>
Date: Fri, 28 Jan 2022 20:50:33 -0500
Subject: [PATCH 160/161] [mono] Fix r8->i conversion on amd64/arm64. (#64467)

Fixes https://github.com/dotnet/runtime/issues/64386.
---
 src/mono/mono/mini/mini-amd64.c | 2 +-
 src/mono/mono/mini/mini-arm64.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/mono/mono/mini/mini-amd64.c b/src/mono/mono/mini/mini-amd64.c
index 72c5d1e34060e5..838fb352d75e34 100644
--- a/src/mono/mono/mini/mini-amd64.c
+++ b/src/mono/mono/mini/mini-amd64.c
@@ -6011,9 +6011,9 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 			code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, FALSE);
 			break;
 		case OP_FCONV_TO_I4:
-		case OP_FCONV_TO_I:
 			code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, TRUE);
 			break;
+		case OP_FCONV_TO_I:
 		case OP_FCONV_TO_I8:
 			code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 8, TRUE);
 			break;
diff --git a/src/mono/mono/mini/mini-arm64.c b/src/mono/mono/mini/mini-arm64.c
index 64ed1fadc63f83..28b97fac4786a8 100644
--- a/src/mono/mono/mini/mini-arm64.c
+++ b/src/mono/mono/mini/mini-arm64.c
@@ -4226,7 +4226,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 			arm_uxthw (code, dreg, dreg);
 			break;
 		case OP_FCONV_TO_I4:
-		case OP_FCONV_TO_I:
 			arm_fcvtzs_dx (code, dreg, sreg1);
 			arm_sxtwx (code, dreg, dreg);
 			break;
@@ -4234,6 +4233,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
 			arm_fcvtzu_dx (code, dreg, sreg1);
 			break;
 		case OP_FCONV_TO_I8:
+		case OP_FCONV_TO_I:
 			arm_fcvtzs_dx (code, dreg, sreg1);
 			break;
 		case OP_FCONV_TO_U8:

From 874d6a3e33c1b9370ac1cb2a6b0f796bdb4b0242 Mon Sep 17 00:00:00 2001
From: Roman Marusyk <Marusyk@users.noreply.github.com>
Date: Sat, 29 Jan 2022 05:20:10 +0200
Subject: [PATCH 161/161] Remove CheckForOverflowUnderflow (#63825)

* Remove set false to CheckForOverflowUnderflow due to it is disabled by default

* Use checked instead of CheckForOverflowUnderflow
---
 src/libraries/Directory.Build.props                        | 2 --
 src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.cs    | 7 +++++--
 .../JIT/Regression/Dev11/dev11_4421/Dev11_4421.csproj      | 1 -
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/libraries/Directory.Build.props b/src/libraries/Directory.Build.props
index 49c6d278ee1d2f..a5cc7f68250084 100644
--- a/src/libraries/Directory.Build.props
+++ b/src/libraries/Directory.Build.props
@@ -87,8 +87,6 @@
 
   <!-- Language configuration -->
   <PropertyGroup>
-    <!-- We decided to keep this disabled by default: https://github.com/dotnet/runtime/issues/15152 -->
-    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
     <GenFacadesIgnoreBuildAndRevisionMismatch>true</GenFacadesIgnoreBuildAndRevisionMismatch>
     <!-- Disable analyzers for tests and unsupported projects -->
     <RunAnalyzers Condition="'$(IsTestProject)' != 'true' and '$(IsSourceProject)' != 'true'">false</RunAnalyzers>
diff --git a/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.cs b/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.cs
index f85ed85ceb0ee0..8bd8ef26522244 100644
--- a/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.cs
+++ b/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.cs
@@ -10,8 +10,11 @@ private static int Main()
         int Var1, Temp;
         try
         {
-            for (Temp = int.MaxValue - 3; Temp <= int.MaxValue - 1; Temp++)
-                Var1 = (int)(2 + Temp);
+            checked
+            {
+                for (Temp = int.MaxValue - 3; Temp <= int.MaxValue - 1; Temp++)
+                    Var1 = (int)(2 + Temp);
+            }
         }
         catch (Exception ex)
         {
diff --git a/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.csproj b/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.csproj
index 0ac905c8265b7a..68c5b85dcaba41 100644
--- a/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.csproj
+++ b/src/tests/JIT/Regression/Dev11/dev11_4421/Dev11_4421.csproj
@@ -5,7 +5,6 @@
   <PropertyGroup>
     <DebugType>PdbOnly</DebugType>
     <Optimize>True</Optimize>
-    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Dev11_4421.cs" />